IVGCVSW-4893 Refactor ILayerVisitor using unified interface strategy.
Signed-off-by: Jan Eilers <jan.eilers@arm.com>
Signed-off-by: Finn Williams <Finn.Williams@arm.com>
Signed-off-by: Francis Murtagh <francis.murtagh@arm.com>
Change-Id: Id7bc8255a8e3f9e5aac65d510bec8a559bf37246
diff --git a/src/armnnSerializer/Serializer.cpp b/src/armnnSerializer/Serializer.cpp
index 28afac7..bcdaa08 100644
--- a/src/armnnSerializer/Serializer.cpp
+++ b/src/armnnSerializer/Serializer.cpp
@@ -3,6 +3,7 @@
// SPDX-License-Identifier: MIT
//
#include "Serializer.hpp"
+#include "SerializerUtils.hpp"
#include <armnn/Descriptors.hpp>
#include <armnn/LstmParams.hpp>
@@ -10,9 +11,9 @@
#include <armnn/utility/IgnoreUnused.hpp>
#include <armnn/utility/NumericCast.hpp>
+#include <fmt/format.h>
#include <iostream>
-#include "SerializerUtils.hpp"
using namespace armnn;
namespace fb = flatbuffers;
@@ -95,7 +96,7 @@
}
}
-uint32_t SerializerVisitor::GetSerializedId(armnn::LayerGuid guid)
+uint32_t SerializerStrategy::GetSerializedId(armnn::LayerGuid guid)
{
if (m_guidMap.empty())
{
@@ -112,7 +113,7 @@
}
// Build FlatBuffer for Input Layer
-void SerializerVisitor::VisitInputLayer(const armnn::IConnectableLayer* layer, LayerBindingId id, const char* name)
+void SerializerStrategy::SerializeInputLayer(const armnn::IConnectableLayer* layer, LayerBindingId id, const char* name)
{
IgnoreUnused(name);
@@ -134,7 +135,8 @@
}
// Build FlatBuffer for Output Layer
-void SerializerVisitor::VisitOutputLayer(const armnn::IConnectableLayer* layer, LayerBindingId id, const char* name)
+void SerializerStrategy::SerializeOutputLayer(const armnn::IConnectableLayer* layer,
+ LayerBindingId id, const char* name)
{
IgnoreUnused(name);
@@ -154,7 +156,7 @@
CreateAnyLayer(flatBufferOutputLayer.o, serializer::Layer::Layer_OutputLayer);
}
-void SerializerVisitor::VisitAbsLayer(const armnn::IConnectableLayer* layer, const char* name)
+void SerializerStrategy::SerializeAbsLayer(const armnn::IConnectableLayer* layer, const char* name)
{
IgnoreUnused(name);
auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Abs);
@@ -164,9 +166,9 @@
}
// Build FlatBuffer for Activation Layer
-void SerializerVisitor::VisitActivationLayer(const armnn::IConnectableLayer* layer,
- const armnn::ActivationDescriptor& descriptor,
- const char* name)
+void SerializerStrategy::SerializeActivationLayer(const armnn::IConnectableLayer* layer,
+ const armnn::ActivationDescriptor& descriptor,
+ const char* name)
{
IgnoreUnused(name);
@@ -189,7 +191,7 @@
}
// Build FlatBuffer for Addition Layer
-void SerializerVisitor::VisitAdditionLayer(const armnn::IConnectableLayer* layer, const char* name)
+void SerializerStrategy::SerializeAdditionLayer(const armnn::IConnectableLayer* layer, const char* name)
{
IgnoreUnused(name);
@@ -204,9 +206,9 @@
}
// Build FlatBuffer for ArgMinMax Layer
-void SerializerVisitor::VisitArgMinMaxLayer(const armnn::IConnectableLayer *layer,
- const armnn::ArgMinMaxDescriptor& descriptor,
- const char *name)
+void SerializerStrategy::SerializeArgMinMaxLayer(const armnn::IConnectableLayer *layer,
+ const armnn::ArgMinMaxDescriptor& descriptor,
+ const char *name)
{
IgnoreUnused(name);
@@ -227,9 +229,9 @@
}
// Build FlatBuffer for BatchToSpaceNd Layer
-void SerializerVisitor::VisitBatchToSpaceNdLayer(const armnn::IConnectableLayer* layer,
- const armnn::BatchToSpaceNdDescriptor& descriptor,
- const char* name)
+void SerializerStrategy::SerializeBatchToSpaceNdLayer(const armnn::IConnectableLayer* layer,
+ const armnn::BatchToSpaceNdDescriptor& descriptor,
+ const char* name)
{
IgnoreUnused(name);
@@ -257,16 +259,19 @@
CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_BatchToSpaceNdLayer);
}
-void SerializerVisitor::VisitBatchNormalizationLayer(const armnn::IConnectableLayer* layer,
- const armnn::BatchNormalizationDescriptor& batchNormDescriptor,
- const armnn::ConstTensor& mean,
- const armnn::ConstTensor& variance,
- const armnn::ConstTensor& beta,
- const armnn::ConstTensor& gamma,
- const char* name)
+void SerializerStrategy::SerializeBatchNormalizationLayer(
+ const armnn::IConnectableLayer* layer,
+ const armnn::BatchNormalizationDescriptor& batchNormDescriptor,
+ const std::vector<armnn::ConstTensor>& constants,
+ const char* name)
{
IgnoreUnused(name);
+ const armnn::ConstTensor& mean = constants[0];
+ const armnn::ConstTensor& variance = constants[1];
+ const armnn::ConstTensor& beta = constants[2];
+ const armnn::ConstTensor& gamma = constants[3];
+
auto fbBatchNormalizationBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_BatchNormalization);
auto fbBatchNormalizationDescriptor = serializer::CreateBatchNormalizationDescriptor(
m_flatBufferBuilder,
@@ -288,7 +293,7 @@
CreateAnyLayer(fbBatchNormalizationLayer.o, serializer::Layer::Layer_BatchNormalizationLayer);
}
-void SerializerVisitor::VisitComparisonLayer(const armnn::IConnectableLayer* layer,
+void SerializerStrategy::SerializeComparisonLayer(const armnn::IConnectableLayer* layer,
const armnn::ComparisonDescriptor& descriptor,
const char* name)
{
@@ -304,12 +309,14 @@
}
// Build FlatBuffer for Constant Layer
-void SerializerVisitor::VisitConstantLayer(const armnn::IConnectableLayer* layer,
- const armnn::ConstTensor& input,
- const char* name)
+void SerializerStrategy::SerializeConstantLayer(const armnn::IConnectableLayer* layer,
+ const std::vector<armnn::ConstTensor>& constants,
+ const char* name)
{
IgnoreUnused(name);
+ armnn::ConstTensor input = constants[0];
+
// Create FlatBuffer BaseLayer
auto flatBufferConstantBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Constant);
@@ -325,14 +332,15 @@
}
// Build FlatBuffer for Convolution2dLayer
-void SerializerVisitor::VisitConvolution2dLayer(const armnn::IConnectableLayer* layer,
- const armnn::Convolution2dDescriptor& descriptor,
- const armnn::ConstTensor& weights,
- const armnn::Optional<armnn::ConstTensor>& biases,
- const char* name)
+void SerializerStrategy::SerializeConvolution2dLayer(const armnn::IConnectableLayer* layer,
+ const armnn::Convolution2dDescriptor& descriptor,
+ const std::vector<armnn::ConstTensor>& constants,
+ const char* name)
{
IgnoreUnused(name);
+ const armnn::ConstTensor weights = constants[0];
+
// Create FlatBuffer BaseLayer
auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Convolution2d);
@@ -350,9 +358,10 @@
auto flatBufferWeightsConstTensorInfo = CreateConstTensorInfo(weights);
flatbuffers::Offset<serializer::ConstTensor> flatBufferBiasesConstTensorInfo;
- if (biases.has_value())
+ if (constants.size() > 1)
{
- flatBufferBiasesConstTensorInfo = CreateConstTensorInfo(biases.value());
+ const armnn::ConstTensor biases = constants[1];
+ flatBufferBiasesConstTensorInfo = CreateConstTensorInfo(biases);
}
// Create the FlatBuffer Convolution2dLayer
@@ -366,7 +375,7 @@
CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_Convolution2dLayer);
}
-void SerializerVisitor::VisitDepthToSpaceLayer(const armnn::IConnectableLayer* layer,
+void SerializerStrategy::SerializeDepthToSpaceLayer(const armnn::IConnectableLayer* layer,
const armnn::DepthToSpaceDescriptor& descriptor,
const char* name)
{
@@ -382,14 +391,15 @@
CreateAnyLayer(fbLayer.o, serializer::Layer::Layer_DepthToSpaceLayer);
}
-void SerializerVisitor::VisitDepthwiseConvolution2dLayer(const armnn::IConnectableLayer* layer,
- const armnn::DepthwiseConvolution2dDescriptor& descriptor,
- const armnn::ConstTensor& weights,
- const armnn::Optional<armnn::ConstTensor>& biases,
- const char* name)
+void SerializerStrategy::SerializeDepthwiseConvolution2dLayer(const armnn::IConnectableLayer* layer,
+ const armnn::DepthwiseConvolution2dDescriptor& descriptor,
+ const std::vector<armnn::ConstTensor>& constants,
+ const char* name)
{
IgnoreUnused(name);
+ const armnn::ConstTensor& weights = constants[0];
+
auto fbBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_DepthwiseConvolution2d);
auto fbDescriptor = CreateDepthwiseConvolution2dDescriptor(m_flatBufferBuilder,
descriptor.m_PadLeft,
@@ -405,9 +415,11 @@
flatbuffers::Offset<serializer::ConstTensor> fbWeightsConstTensorInfo = CreateConstTensorInfo(weights);
flatbuffers::Offset<serializer::ConstTensor> fbBiasesConstTensorInfo;
- if (biases.has_value())
+
+ if (constants.size() > 1)
{
- fbBiasesConstTensorInfo = CreateConstTensorInfo(biases.value());
+ const armnn::ConstTensor& biases = constants[1];
+ fbBiasesConstTensorInfo = CreateConstTensorInfo(biases);
}
auto flatBufferLayer = CreateDepthwiseConvolution2dLayer(m_flatBufferBuilder,
@@ -419,7 +431,7 @@
CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_DepthwiseConvolution2dLayer);
}
-void SerializerVisitor::VisitDequantizeLayer(const armnn::IConnectableLayer* layer,
+void SerializerStrategy::SerializeDequantizeLayer(const armnn::IConnectableLayer* layer,
const char* name)
{
IgnoreUnused(name);
@@ -430,13 +442,15 @@
CreateAnyLayer(fbDequantizeLayer.o, serializer::Layer::Layer_DequantizeLayer);
}
-void SerializerVisitor::VisitDetectionPostProcessLayer(const armnn::IConnectableLayer* layer,
- const armnn::DetectionPostProcessDescriptor& descriptor,
- const armnn::ConstTensor& anchors,
- const char* name)
+void SerializerStrategy::SerializeDetectionPostProcessLayer(const armnn::IConnectableLayer* layer,
+ const armnn::DetectionPostProcessDescriptor& descriptor,
+ const std::vector<armnn::ConstTensor>& constants,
+ const char* name)
{
IgnoreUnused(name);
+ const armnn::ConstTensor& anchors = constants[0];
+
auto fbBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_DetectionPostProcess);
auto fbDescriptor = CreateDetectionPostProcessDescriptor(m_flatBufferBuilder,
descriptor.m_MaxDetections,
@@ -461,7 +475,7 @@
CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_DetectionPostProcessLayer);
}
-void SerializerVisitor::VisitDivisionLayer(const armnn::IConnectableLayer* layer, const char* name)
+void SerializerStrategy::SerializeDivisionLayer(const armnn::IConnectableLayer* layer, const char* name)
{
IgnoreUnused(name);
@@ -471,7 +485,7 @@
CreateAnyLayer(fbDivisionLayer.o, serializer::Layer::Layer_DivisionLayer);
}
-void SerializerVisitor::VisitElementwiseUnaryLayer(const armnn::IConnectableLayer* layer,
+void SerializerStrategy::SerializeElementwiseUnaryLayer(const armnn::IConnectableLayer* layer,
const armnn::ElementwiseUnaryDescriptor& descriptor,
const char* name)
{
@@ -486,7 +500,7 @@
CreateAnyLayer(fbLayer.o, serializer::Layer::Layer_ElementwiseUnaryLayer);
}
-void SerializerVisitor::VisitEqualLayer(const armnn::IConnectableLayer* layer, const char* name)
+void SerializerStrategy::SerializeEqualLayer(const armnn::IConnectableLayer* layer, const char* name)
{
IgnoreUnused(name);
@@ -496,7 +510,7 @@
CreateAnyLayer(fbEqualLayer.o, serializer::Layer::Layer_EqualLayer);
}
-void SerializerVisitor::VisitFillLayer(const armnn::IConnectableLayer* layer,
+void SerializerStrategy::SerializeFillLayer(const armnn::IConnectableLayer* layer,
const armnn::FillDescriptor& fillDescriptor,
const char* name)
{
@@ -511,7 +525,7 @@
CreateAnyLayer(fbFillLayer.o, serializer::Layer::Layer_FillLayer);
}
-void SerializerVisitor::VisitFloorLayer(const armnn::IConnectableLayer *layer, const char *name)
+void SerializerStrategy::SerializeFloorLayer(const armnn::IConnectableLayer *layer, const char *name)
{
IgnoreUnused(name);
@@ -521,14 +535,7 @@
CreateAnyLayer(flatBufferFloorLayer.o, serializer::Layer::Layer_FloorLayer);
}
-void SerializerVisitor::VisitGatherLayer(const armnn::IConnectableLayer* layer,
- const char* name)
-{
- armnn::GatherDescriptor gatherDescriptor{};
- VisitGatherLayer(layer, gatherDescriptor, name);
-}
-
-void SerializerVisitor::VisitGatherLayer(const armnn::IConnectableLayer* layer,
+void SerializerStrategy::SerializeGatherLayer(const armnn::IConnectableLayer* layer,
const armnn::GatherDescriptor& gatherDescriptor,
const char* name)
{
@@ -542,7 +549,8 @@
CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_GatherLayer);
}
-void SerializerVisitor::VisitGreaterLayer(const armnn::IConnectableLayer* layer, const char* name)
+
+void SerializerStrategy::SerializeGreaterLayer(const armnn::IConnectableLayer* layer, const char* name)
{
IgnoreUnused(name);
@@ -552,7 +560,7 @@
CreateAnyLayer(fbGreaterLayer.o, serializer::Layer::Layer_GreaterLayer);
}
-void SerializerVisitor::VisitInstanceNormalizationLayer(
+void SerializerStrategy::SerializeInstanceNormalizationLayer(
const armnn::IConnectableLayer* layer,
const armnn::InstanceNormalizationDescriptor& instanceNormalizationDescriptor,
const char* name)
@@ -572,7 +580,7 @@
CreateAnyLayer(fbLayer.o, serializer::Layer::Layer_InstanceNormalizationLayer);
}
-void SerializerVisitor::VisitL2NormalizationLayer(const armnn::IConnectableLayer* layer,
+void SerializerStrategy::SerializeL2NormalizationLayer(const armnn::IConnectableLayer* layer,
const armnn::L2NormalizationDescriptor& l2NormalizationDescriptor,
const char* name)
{
@@ -593,7 +601,7 @@
CreateAnyLayer(fbLayer.o, serializer::Layer::Layer_L2NormalizationLayer);
}
-void SerializerVisitor::VisitLogicalBinaryLayer(const armnn::IConnectableLayer* layer,
+void SerializerStrategy::SerializeLogicalBinaryLayer(const armnn::IConnectableLayer* layer,
const armnn::LogicalBinaryDescriptor& descriptor,
const char* name)
{
@@ -608,7 +616,7 @@
CreateAnyLayer(fbLayer.o, serializer::Layer::Layer_LogicalBinaryLayer);
}
-void SerializerVisitor::VisitLogSoftmaxLayer(const armnn::IConnectableLayer* layer,
+void SerializerStrategy::SerializeLogSoftmaxLayer(const armnn::IConnectableLayer* layer,
const armnn::LogSoftmaxDescriptor& logSoftmaxDescriptor,
const char* name)
{
@@ -632,10 +640,10 @@
CreateAnyLayer(flatBufferLogSoftmaxLayer.o, serializer::Layer::Layer_LogSoftmaxLayer);
}
-void SerializerVisitor::VisitLstmLayer(const armnn::IConnectableLayer* layer,
- const armnn::LstmDescriptor& descriptor,
- const armnn::LstmInputParams& params,
- const char* name)
+void SerializerStrategy::SerializeLstmLayer(const armnn::IConnectableLayer* layer,
+ const armnn::LstmDescriptor& descriptor,
+ const std::vector<armnn::ConstTensor>& constants,
+ const char* name)
{
IgnoreUnused(name);
@@ -651,16 +659,21 @@
descriptor.m_ProjectionEnabled,
descriptor.m_LayerNormEnabled);
- // Get mandatory input parameters
- auto inputToForgetWeights = CreateConstTensorInfo(*params.m_InputToForgetWeights);
- auto inputToCellWeights = CreateConstTensorInfo(*params.m_InputToCellWeights);
- auto inputToOutputWeights = CreateConstTensorInfo(*params.m_InputToOutputWeights);
- auto recurrentToForgetWeights = CreateConstTensorInfo(*params.m_RecurrentToForgetWeights);
- auto recurrentToCellWeights = CreateConstTensorInfo(*params.m_RecurrentToCellWeights);
- auto recurrentToOutputWeights = CreateConstTensorInfo(*params.m_RecurrentToOutputWeights);
- auto forgetGateBias = CreateConstTensorInfo(*params.m_ForgetGateBias);
- auto cellBias = CreateConstTensorInfo(*params.m_CellBias);
- auto outputGateBias = CreateConstTensorInfo(*params.m_OutputGateBias);
+ // Index for constants vector
+ std::size_t i = 0;
+
+ // Get mandatory/basic input parameters
+ auto inputToForgetWeights = CreateConstTensorInfo(constants[i++]); //InputToForgetWeights
+ auto inputToCellWeights = CreateConstTensorInfo(constants[i++]); //InputToCellWeights
+ auto inputToOutputWeights = CreateConstTensorInfo(constants[i++]); //InputToOutputWeights
+ auto recurrentToForgetWeights = CreateConstTensorInfo(constants[i++]); //RecurrentToForgetWeights
+ auto recurrentToCellWeights = CreateConstTensorInfo(constants[i++]); //RecurrentToCellWeights
+ auto recurrentToOutputWeights = CreateConstTensorInfo(constants[i++]); //RecurrentToOutputWeights
+ auto forgetGateBias = CreateConstTensorInfo(constants[i++]); //ForgetGateBias
+ auto cellBias = CreateConstTensorInfo(constants[i++]); //CellBias
+ auto outputGateBias = CreateConstTensorInfo(constants[i++]); //OutputGateBias
+
+
//Define optional parameters, these will be set depending on configuration in Lstm descriptor
flatbuffers::Offset<serializer::ConstTensor> inputToInputWeights;
@@ -678,33 +691,36 @@
if (!descriptor.m_CifgEnabled)
{
- inputToInputWeights = CreateConstTensorInfo(*params.m_InputToInputWeights);
- recurrentToInputWeights = CreateConstTensorInfo(*params.m_RecurrentToInputWeights);
- cellToInputWeights = CreateConstTensorInfo(*params.m_CellToInputWeights);
- inputGateBias = CreateConstTensorInfo(*params.m_InputGateBias);
- }
-
- if (descriptor.m_ProjectionEnabled)
- {
- projectionWeights = CreateConstTensorInfo(*params.m_ProjectionWeights);
- projectionBias = CreateConstTensorInfo(*params.m_ProjectionBias);
+ inputToInputWeights = CreateConstTensorInfo(constants[i++]); //InputToInputWeights
+ recurrentToInputWeights = CreateConstTensorInfo(constants[i++]); //RecurrentToInputWeights
+ inputGateBias = CreateConstTensorInfo(constants[i++]); //InputGateBias
}
if (descriptor.m_PeepholeEnabled)
{
- cellToForgetWeights = CreateConstTensorInfo(*params.m_CellToForgetWeights);
- cellToOutputWeights = CreateConstTensorInfo(*params.m_CellToOutputWeights);
+ if (!descriptor.m_CifgEnabled)
+ {
+ cellToInputWeights = CreateConstTensorInfo(constants[i++]); //CellToInputWeights
+ }
+ cellToForgetWeights = CreateConstTensorInfo(constants[i++]); //CellToForgetWeights
+ cellToOutputWeights = CreateConstTensorInfo(constants[i++]); //CellToOutputWeights
+ }
+
+ if (descriptor.m_ProjectionEnabled)
+ {
+ projectionWeights = CreateConstTensorInfo(constants[i++]); //ProjectionWeights
+ projectionBias = CreateConstTensorInfo(constants[i++]); //ProjectionBias
}
if (descriptor.m_LayerNormEnabled)
{
if (!descriptor.m_CifgEnabled)
{
- inputLayerNormWeights = CreateConstTensorInfo((*params.m_InputLayerNormWeights));
+ inputLayerNormWeights = CreateConstTensorInfo(constants[i++]); //InputLayerNormWeights
}
- forgetLayerNormWeights = CreateConstTensorInfo(*params.m_ForgetLayerNormWeights);
- cellLayerNormWeights = CreateConstTensorInfo(*params.m_CellLayerNormWeights);
- outputLayerNormWeights = CreateConstTensorInfo(*params.m_OutputLayerNormWeights);
+ forgetLayerNormWeights = CreateConstTensorInfo(constants[i++]); //ForgetLayerNormWeights
+ cellLayerNormWeights = CreateConstTensorInfo(constants[i++]); //CellLayerNormWeights
+ outputLayerNormWeights = CreateConstTensorInfo(constants[i++]); //OutputLayerNormWeights
}
auto fbLstmParams = serializer::CreateLstmInputParams(
@@ -740,7 +756,7 @@
CreateAnyLayer(fbLstmLayer.o, serializer::Layer::Layer_LstmLayer);
}
-void SerializerVisitor::VisitMaximumLayer(const armnn::IConnectableLayer* layer, const char* name)
+void SerializerStrategy::SerializeMaximumLayer(const armnn::IConnectableLayer* layer, const char* name)
{
IgnoreUnused(name);
@@ -750,7 +766,7 @@
CreateAnyLayer(fbMaximumLayer.o, serializer::Layer::Layer_MaximumLayer);
}
-void SerializerVisitor::VisitMeanLayer(const armnn::IConnectableLayer* layer,
+void SerializerStrategy::SerializeMeanLayer(const armnn::IConnectableLayer* layer,
const armnn::MeanDescriptor& descriptor,
const char* name)
{
@@ -768,7 +784,7 @@
CreateAnyLayer(fbMeanLayer.o, serializer::Layer::Layer_MeanLayer);
}
-void SerializerVisitor::VisitMinimumLayer(const armnn::IConnectableLayer* layer, const char* name)
+void SerializerStrategy::SerializeMinimumLayer(const armnn::IConnectableLayer* layer, const char* name)
{
IgnoreUnused(name);
@@ -778,7 +794,7 @@
CreateAnyLayer(fbMinimumLayer.o, serializer::Layer::Layer_MinimumLayer);
}
-void SerializerVisitor::VisitMergeLayer(const armnn::IConnectableLayer* layer, const char* name)
+void SerializerStrategy::SerializeMergeLayer(const armnn::IConnectableLayer* layer, const char* name)
{
IgnoreUnused(name);
@@ -788,14 +804,14 @@
CreateAnyLayer(fbMergeLayer.o, serializer::Layer::Layer_MergeLayer);
}
-void SerializerVisitor::VisitMergerLayer(const armnn::IConnectableLayer* layer,
+void SerializerStrategy::SerializeMergerLayer(const armnn::IConnectableLayer* layer,
const armnn::MergerDescriptor& mergerDescriptor,
const char* name)
{
- VisitConcatLayer(layer, mergerDescriptor, name);
+ SerializeConcatLayer(layer, mergerDescriptor, name);
}
-void SerializerVisitor::VisitConcatLayer(const armnn::IConnectableLayer* layer,
+void SerializerStrategy::SerializeConcatLayer(const armnn::IConnectableLayer* layer,
const armnn::ConcatDescriptor& concatDescriptor,
const char* name)
{
@@ -830,7 +846,7 @@
CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_ConcatLayer);
}
-void SerializerVisitor::VisitMultiplicationLayer(const armnn::IConnectableLayer* layer, const char* name)
+void SerializerStrategy::SerializeMultiplicationLayer(const armnn::IConnectableLayer* layer, const char* name)
{
IgnoreUnused(name);
@@ -841,7 +857,7 @@
CreateAnyLayer(fbMultiplicationLayer.o, serializer::Layer::Layer_MultiplicationLayer);
}
-void SerializerVisitor::VisitPadLayer(const armnn::IConnectableLayer* layer,
+void SerializerStrategy::SerializePadLayer(const armnn::IConnectableLayer* layer,
const armnn::PadDescriptor& padDescriptor,
const char* name)
{
@@ -867,7 +883,7 @@
CreateAnyLayer(flatBufferPadLayer.o, serializer::Layer::Layer_PadLayer);
}
-void SerializerVisitor::VisitPermuteLayer(const armnn::IConnectableLayer* layer,
+void SerializerStrategy::SerializePermuteLayer(const armnn::IConnectableLayer* layer,
const armnn::PermuteDescriptor& permuteDescriptor,
const char* name)
{
@@ -895,7 +911,7 @@
}
// Build FlatBuffer for Rank Layer
-void SerializerVisitor::VisitRankLayer(const armnn::IConnectableLayer* layer,
+void SerializerStrategy::SerializeRankLayer(const armnn::IConnectableLayer* layer,
const char* name)
{
IgnoreUnused(name);
@@ -905,9 +921,9 @@
CreateAnyLayer(flatBufferRankLayer.o, serializer::Layer::Layer_RankLayer);
}
-void SerializerVisitor::VisitReduceLayer(const armnn::IConnectableLayer* layer,
- const armnn::ReduceDescriptor& reduceDescriptor,
- const char*)
+void SerializerStrategy::SerializeReduceLayer(const armnn::IConnectableLayer* layer,
+ const armnn::ReduceDescriptor& reduceDescriptor,
+ const char*)
{
auto fbReduceBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Reduce);
auto fbDescriptor = CreateReduceDescriptor(m_flatBufferBuilder,
@@ -922,7 +938,7 @@
}
// Build FlatBuffer for Reshape Layer
-void SerializerVisitor::VisitReshapeLayer(const armnn::IConnectableLayer* layer,
+void SerializerStrategy::SerializeReshapeLayer(const armnn::IConnectableLayer* layer,
const armnn::ReshapeDescriptor& reshapeDescriptor,
const char* name)
{
@@ -948,7 +964,7 @@
CreateAnyLayer(flatBufferReshapeLayer.o, serializer::Layer::Layer_ReshapeLayer);
}
-void SerializerVisitor::VisitResizeBilinearLayer(const armnn::IConnectableLayer* layer,
+void SerializerStrategy::SerializeResizeBilinearLayer(const armnn::IConnectableLayer* layer,
const armnn::ResizeBilinearDescriptor& resizeDescriptor,
const char* name)
{
@@ -971,7 +987,7 @@
CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_ResizeBilinearLayer);
}
-void SerializerVisitor::VisitResizeLayer(const armnn::IConnectableLayer* layer,
+void SerializerStrategy::SerializeResizeLayer(const armnn::IConnectableLayer* layer,
const armnn::ResizeDescriptor& resizeDescriptor,
const char* name)
{
@@ -995,7 +1011,7 @@
CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_ResizeLayer);
}
-void SerializerVisitor::VisitRsqrtLayer(const armnn::IConnectableLayer* layer, const char* name)
+void SerializerStrategy::SerializeRsqrtLayer(const armnn::IConnectableLayer* layer, const char* name)
{
IgnoreUnused(name);
@@ -1005,7 +1021,7 @@
CreateAnyLayer(fbRsqrtLayer.o, serializer::Layer::Layer_RsqrtLayer);
}
-void SerializerVisitor::VisitSliceLayer(const armnn::IConnectableLayer* layer,
+void SerializerStrategy::SerializeSliceLayer(const armnn::IConnectableLayer* layer,
const armnn::SliceDescriptor& sliceDescriptor,
const char* name)
{
@@ -1022,7 +1038,7 @@
}
// Build FlatBuffer for Softmax Layer
-void SerializerVisitor::VisitSoftmaxLayer(const armnn::IConnectableLayer* layer,
+void SerializerStrategy::SerializeSoftmaxLayer(const armnn::IConnectableLayer* layer,
const armnn::SoftmaxDescriptor& softmaxDescriptor,
const char* name)
{
@@ -1044,7 +1060,7 @@
CreateAnyLayer(flatBufferSoftmaxLayer.o, serializer::Layer::Layer_SoftmaxLayer);
}
-void SerializerVisitor::VisitPooling2dLayer(const armnn::IConnectableLayer* layer,
+void SerializerStrategy::SerializePooling2dLayer(const armnn::IConnectableLayer* layer,
const armnn::Pooling2dDescriptor& pooling2dDescriptor,
const char* name)
{
@@ -1073,7 +1089,7 @@
CreateAnyLayer(fbPooling2dLayer.o, serializer::Layer::Layer_Pooling2dLayer);
}
-void SerializerVisitor::VisitPreluLayer(const armnn::IConnectableLayer* layer,
+void SerializerStrategy::SerializePreluLayer(const armnn::IConnectableLayer* layer,
const char* name)
{
IgnoreUnused(name);
@@ -1088,7 +1104,7 @@
CreateAnyLayer(flatBufferPreluLayer.o, serializer::Layer::Layer_PreluLayer);
}
-void SerializerVisitor::VisitQuantizeLayer(const armnn::IConnectableLayer *layer, const char *name)
+void SerializerStrategy::SerializeQuantizeLayer(const armnn::IConnectableLayer *layer, const char *name)
{
IgnoreUnused(name);
@@ -1099,14 +1115,15 @@
}
// Build FlatBuffer for FullyConnected Layer
-void SerializerVisitor::VisitFullyConnectedLayer(const armnn::IConnectableLayer* layer,
- const armnn::FullyConnectedDescriptor& fullyConnectedDescriptor,
- const armnn::ConstTensor& weights,
- const armnn::Optional<armnn::ConstTensor>& biases,
- const char* name)
+void SerializerStrategy::SerializeFullyConnectedLayer(const armnn::IConnectableLayer* layer,
+ const armnn::FullyConnectedDescriptor& fullyConnectedDescriptor,
+ const std::vector<armnn::ConstTensor>& constants,
+ const char* name)
{
IgnoreUnused(name);
+ const armnn::ConstTensor& weights = constants.at(0);
+
// Create FlatBuffer BaseLayer
auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_FullyConnected);
@@ -1123,7 +1140,8 @@
flatbuffers::Offset<serializer::ConstTensor> flatBufferBiases;
if (fullyConnectedDescriptor.m_BiasEnabled)
{
- flatBufferBiases = CreateConstTensorInfo(biases.value());
+ armnn::ConstTensor biases = constants.at(1);
+ flatBufferBiases = CreateConstTensorInfo(biases);
}
// Create FlatBuffer FullyConnectedLayer
@@ -1138,7 +1156,7 @@
}
// Build FlatBuffer for SpaceToBatchNd Layer
-void SerializerVisitor::VisitSpaceToBatchNdLayer(const armnn::IConnectableLayer* layer,
+void SerializerStrategy::SerializeSpaceToBatchNdLayer(const armnn::IConnectableLayer* layer,
const armnn::SpaceToBatchNdDescriptor& spaceToBatchNdDescriptor,
const char* name)
{
@@ -1169,7 +1187,7 @@
}
// Build FlatBuffer for SpaceToDepthLayer
-void SerializerVisitor::VisitSpaceToDepthLayer(const armnn::IConnectableLayer* layer,
+void SerializerStrategy::SerializeSpaceToDepthLayer(const armnn::IConnectableLayer* layer,
const armnn::SpaceToDepthDescriptor& spaceToDepthDescriptor,
const char* name)
{
@@ -1189,7 +1207,7 @@
}
// Build FlatBuffer for Splitter Layer
-void SerializerVisitor::VisitSplitterLayer(const armnn::IConnectableLayer* layer,
+void SerializerStrategy::SerializeSplitterLayer(const armnn::IConnectableLayer* layer,
const armnn::ViewsDescriptor& viewsDescriptor,
const char* name)
{
@@ -1255,7 +1273,7 @@
CreateAnyLayer(flatBufferSplitterLayer.o, serializer::Layer::Layer_SplitterLayer);
}
-void SerializerVisitor::VisitNormalizationLayer(const armnn::IConnectableLayer* layer,
+void SerializerStrategy::SerializeNormalizationLayer(const armnn::IConnectableLayer* layer,
const armnn::NormalizationDescriptor& descriptor,
const char* name)
{
@@ -1280,7 +1298,7 @@
CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_NormalizationLayer);
}
-void SerializerVisitor::VisitStackLayer(const armnn::IConnectableLayer* layer,
+void SerializerStrategy::SerializeStackLayer(const armnn::IConnectableLayer* layer,
const armnn::StackDescriptor& stackDescriptor,
const char* name)
{
@@ -1303,7 +1321,7 @@
CreateAnyLayer(stackLayer.o, serializer::Layer::Layer_StackLayer);
}
-void SerializerVisitor::VisitStandInLayer(const armnn::IConnectableLayer *layer,
+void SerializerStrategy::SerializeStandInLayer(const armnn::IConnectableLayer *layer,
const armnn::StandInDescriptor& standInDescriptor,
const char *name)
{
@@ -1319,7 +1337,7 @@
CreateAnyLayer(fbLayer.o, serializer::Layer::Layer_StandInLayer);
}
-void SerializerVisitor::VisitStridedSliceLayer(const armnn::IConnectableLayer* layer,
+void SerializerStrategy::SerializeStridedSliceLayer(const armnn::IConnectableLayer* layer,
const armnn::StridedSliceDescriptor& stridedSliceDescriptor,
const char* name)
{
@@ -1346,7 +1364,7 @@
CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_StridedSliceLayer);
}
-void SerializerVisitor::VisitSubtractionLayer(const armnn::IConnectableLayer* layer, const char* name)
+void SerializerStrategy::SerializeSubtractionLayer(const armnn::IConnectableLayer* layer, const char* name)
{
IgnoreUnused(name);
@@ -1356,7 +1374,7 @@
CreateAnyLayer(fbSubtractionLayer.o, serializer::Layer::Layer_SubtractionLayer);
}
-void SerializerVisitor::VisitSwitchLayer(const armnn::IConnectableLayer* layer, const char* name)
+void SerializerStrategy::SerializeSwitchLayer(const armnn::IConnectableLayer* layer, const char* name)
{
IgnoreUnused(name);
@@ -1366,15 +1384,16 @@
CreateAnyLayer(fbSwitchLayer.o, serializer::Layer::Layer_SwitchLayer);
}
-void SerializerVisitor::VisitTransposeConvolution2dLayer(
+void SerializerStrategy::SerializeTransposeConvolution2dLayer(
const armnn::IConnectableLayer* layer,
const armnn::TransposeConvolution2dDescriptor& descriptor,
- const armnn::ConstTensor& weights,
- const armnn::Optional<armnn::ConstTensor>& biases,
+ const std::vector<armnn::ConstTensor>& constants,
const char* name)
{
IgnoreUnused(name);
+ const armnn::ConstTensor& weights = constants.at(0);
+
auto fbBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Convolution2d);
auto fbDescriptor = CreateTransposeConvolution2dDescriptor(m_flatBufferBuilder,
descriptor.m_PadLeft,
@@ -1389,9 +1408,10 @@
// weights & biases
auto fbWeightsConstTensorInfo = CreateConstTensorInfo(weights);
flatbuffers::Offset<serializer::ConstTensor> fbBiasesConstTensorInfo;
- if (biases.has_value())
+ if (constants.size() > 1)
{
- fbBiasesConstTensorInfo = CreateConstTensorInfo(biases.value());
+ const armnn::ConstTensor& biases = constants.at(1);
+ fbBiasesConstTensorInfo = CreateConstTensorInfo(biases);
}
auto fbLayer = CreateTransposeConvolution2dLayer(m_flatBufferBuilder,
@@ -1403,7 +1423,7 @@
CreateAnyLayer(fbLayer.o, serializer::Layer::Layer_TransposeConvolution2dLayer);
}
-void SerializerVisitor::VisitTransposeLayer(const armnn::IConnectableLayer* layer,
+void SerializerStrategy::SerializeTransposeLayer(const armnn::IConnectableLayer* layer,
const armnn::TransposeDescriptor& descriptor,
const char* name)
{
@@ -1430,10 +1450,10 @@
CreateAnyLayer(flatBufferLayer.o, serializer::Layer::Layer_TransposeLayer);
}
-void SerializerVisitor::VisitQLstmLayer(const armnn::IConnectableLayer* layer,
- const armnn::QLstmDescriptor& descriptor,
- const armnn::LstmInputParams& params,
- const char* name)
+void SerializerStrategy::SerializeQLstmLayer(const armnn::IConnectableLayer* layer,
+ const armnn::QLstmDescriptor& descriptor,
+ const std::vector<armnn::ConstTensor>& constants,
+ const char* name)
{
IgnoreUnused(name);
@@ -1455,16 +1475,19 @@
descriptor.m_HiddenStateScale
);
+ // Index for constants vector
+ std::size_t i = 0;
+
// Mandatory params
- auto inputToForgetWeights = CreateConstTensorInfo(*params.m_InputToForgetWeights);
- auto inputToCellWeights = CreateConstTensorInfo(*params.m_InputToCellWeights);
- auto inputToOutputWeights = CreateConstTensorInfo(*params.m_InputToOutputWeights);
- auto recurrentToForgetWeights = CreateConstTensorInfo(*params.m_RecurrentToForgetWeights);
- auto recurrentToCellWeights = CreateConstTensorInfo(*params.m_RecurrentToCellWeights);
- auto recurrentToOutputWeights = CreateConstTensorInfo(*params.m_RecurrentToOutputWeights);
- auto forgetGateBias = CreateConstTensorInfo(*params.m_ForgetGateBias);
- auto cellBias = CreateConstTensorInfo(*params.m_CellBias);
- auto outputGateBias = CreateConstTensorInfo(*params.m_OutputGateBias);
+ auto inputToForgetWeights = CreateConstTensorInfo(constants[i++]); //InputToForgetWeights
+ auto inputToCellWeights = CreateConstTensorInfo(constants[i++]); //InputToCellWeights
+ auto inputToOutputWeights = CreateConstTensorInfo(constants[i++]); //InputToOutputWeights
+ auto recurrentToForgetWeights = CreateConstTensorInfo(constants[i++]); //RecurrentToForgetWeights
+ auto recurrentToCellWeights = CreateConstTensorInfo(constants[i++]); //RecurrentToCellWeights
+ auto recurrentToOutputWeights = CreateConstTensorInfo(constants[i++]); //RecurrentToOutputWeights
+ auto forgetGateBias = CreateConstTensorInfo(constants[i++]); //ForgetGateBias
+ auto cellBias = CreateConstTensorInfo(constants[i++]); //CellBias
+ auto outputGateBias = CreateConstTensorInfo(constants[i++]); //OutputGateBias
// CIFG
flatbuffers::Offset<serializer::ConstTensor> inputToInputWeights;
@@ -1473,19 +1496,9 @@
if (!descriptor.m_CifgEnabled)
{
- inputToInputWeights = CreateConstTensorInfo(*params.m_InputToInputWeights);
- recurrentToInputWeights = CreateConstTensorInfo(*params.m_RecurrentToInputWeights);
- inputGateBias = CreateConstTensorInfo(*params.m_InputGateBias);
- }
-
- // Projectiom
- flatbuffers::Offset<serializer::ConstTensor> projectionWeights;
- flatbuffers::Offset<serializer::ConstTensor> projectionBias;
-
- if (descriptor.m_ProjectionEnabled)
- {
- projectionWeights = CreateConstTensorInfo(*params.m_ProjectionWeights);
- projectionBias = CreateConstTensorInfo(*params.m_ProjectionBias);
+ inputToInputWeights = CreateConstTensorInfo(constants[i++]); //InputToInputWeights
+ recurrentToInputWeights = CreateConstTensorInfo(constants[i++]); //RecurrentToInputWeights
+ inputGateBias = CreateConstTensorInfo(constants[i++]); //InputGateBias
}
// Peephole
@@ -1497,11 +1510,20 @@
{
if (!descriptor.m_CifgEnabled)
{
- cellToInputWeights = CreateConstTensorInfo(*params.m_CellToInputWeights);
+ cellToInputWeights = CreateConstTensorInfo(constants[i++]); //CellToInputWeights
}
+ cellToForgetWeights = CreateConstTensorInfo(constants[i++]); //CellToForgetWeights
+ cellToOutputWeights = CreateConstTensorInfo(constants[i++]); //CellToOutputWeights
+ }
- cellToForgetWeights = CreateConstTensorInfo(*params.m_CellToForgetWeights);
- cellToOutputWeights = CreateConstTensorInfo(*params.m_CellToOutputWeights);
+ // Projection
+ flatbuffers::Offset<serializer::ConstTensor> projectionWeights;
+ flatbuffers::Offset<serializer::ConstTensor> projectionBias;
+
+ if (descriptor.m_ProjectionEnabled)
+ {
+ projectionWeights = CreateConstTensorInfo(constants[i++]); //ProjectionWeights
+ projectionBias = CreateConstTensorInfo(constants[i++]); //ProjectionBias
}
// Layer norm
@@ -1514,12 +1536,11 @@
{
if (!descriptor.m_CifgEnabled)
{
- inputLayerNormWeights = CreateConstTensorInfo((*params.m_InputLayerNormWeights));
+ inputLayerNormWeights = CreateConstTensorInfo(constants[i++]); //InputLayerNormWeights
}
-
- forgetLayerNormWeights = CreateConstTensorInfo(*params.m_ForgetLayerNormWeights);
- cellLayerNormWeights = CreateConstTensorInfo(*params.m_CellLayerNormWeights);
- outputLayerNormWeights = CreateConstTensorInfo(*params.m_OutputLayerNormWeights);
+ forgetLayerNormWeights = CreateConstTensorInfo(constants[i++]); //ForgetLayerNormWeights
+ cellLayerNormWeights = CreateConstTensorInfo(constants[i++]); //CellLayerNormWeights
+ outputLayerNormWeights = CreateConstTensorInfo(constants[i++]); //OutputLayerNormWeights
}
auto fbQLstmParams = serializer::CreateQLstmInputParams(
@@ -1555,29 +1576,32 @@
CreateAnyLayer(fbQLstmLayer.o, serializer::Layer::Layer_QLstmLayer);
}
-void SerializerVisitor::VisitQuantizedLstmLayer(const armnn::IConnectableLayer* layer,
- const armnn::QuantizedLstmInputParams& params,
- const char* name)
+void SerializerStrategy::SerializeQuantizedLstmLayer(const armnn::IConnectableLayer* layer,
+ const std::vector<armnn::ConstTensor>& constants,
+ const char* name)
{
IgnoreUnused(name);
auto fbQuantizedLstmBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_QuantizedLstm);
+ // index for constants vector
+ size_t i = 0;
+
// Get input parameters
- auto inputToInputWeights = CreateConstTensorInfo(params.GetInputToInputWeights());
- auto inputToForgetWeights = CreateConstTensorInfo(params.GetInputToForgetWeights());
- auto inputToCellWeights = CreateConstTensorInfo(params.GetInputToCellWeights());
- auto inputToOutputWeights = CreateConstTensorInfo(params.GetInputToOutputWeights());
+ auto inputToInputWeights = CreateConstTensorInfo(constants[i++]);
+ auto inputToForgetWeights = CreateConstTensorInfo(constants[i++]);
+ auto inputToCellWeights = CreateConstTensorInfo(constants[i++]);
+ auto inputToOutputWeights = CreateConstTensorInfo(constants[i++]);
- auto recurrentToInputWeights = CreateConstTensorInfo(params.GetRecurrentToInputWeights());
- auto recurrentToForgetWeights = CreateConstTensorInfo(params.GetRecurrentToForgetWeights());
- auto recurrentToCellWeights = CreateConstTensorInfo(params.GetRecurrentToCellWeights());
- auto recurrentToOutputWeights = CreateConstTensorInfo(params.GetRecurrentToOutputWeights());
+ auto recurrentToInputWeights = CreateConstTensorInfo(constants[i++]);
+ auto recurrentToForgetWeights = CreateConstTensorInfo(constants[i++]);
+ auto recurrentToCellWeights = CreateConstTensorInfo(constants[i++]);
+ auto recurrentToOutputWeights = CreateConstTensorInfo(constants[i++]);
- auto inputGateBias = CreateConstTensorInfo(params.GetInputGateBias());
- auto forgetGateBias = CreateConstTensorInfo(params.GetForgetGateBias());
- auto cellBias = CreateConstTensorInfo(params.GetCellBias());
- auto outputGateBias = CreateConstTensorInfo(params.GetOutputGateBias());
+ auto inputGateBias = CreateConstTensorInfo(constants[i++]);
+ auto forgetGateBias = CreateConstTensorInfo(constants[i++]);
+ auto cellBias = CreateConstTensorInfo(constants[i++]);
+ auto outputGateBias = CreateConstTensorInfo(constants[i++]);
auto fbQuantizedLstmParams = serializer::CreateQuantizedLstmInputParams(
m_flatBufferBuilder,
@@ -1602,7 +1626,7 @@
CreateAnyLayer(fbQuantizedLstmLayer.o, serializer::Layer::Layer_QuantizedLstmLayer);
}
-fb::Offset<serializer::LayerBase> SerializerVisitor::CreateLayerBase(const IConnectableLayer* layer,
+fb::Offset<serializer::LayerBase> SerializerStrategy::CreateLayerBase(const IConnectableLayer* layer,
const serializer::LayerType layerType)
{
@@ -1619,7 +1643,7 @@
m_flatBufferBuilder.CreateVector(outputSlots));
}
-void SerializerVisitor::CreateAnyLayer(const flatbuffers::Offset<void>& layer, const serializer::Layer serializerLayer)
+void SerializerStrategy::CreateAnyLayer(const flatbuffers::Offset<void>& layer, const serializer::Layer serializerLayer)
{
auto anyLayer = armnnSerializer::CreateAnyLayer(m_flatBufferBuilder, serializerLayer, layer);
@@ -1627,7 +1651,7 @@
}
template <typename T>
-flatbuffers::Offset<flatbuffers::Vector<T>> SerializerVisitor::CreateDataVector(const void* memory, unsigned int size)
+flatbuffers::Offset<flatbuffers::Vector<T>> SerializerStrategy::CreateDataVector(const void* memory, unsigned int size)
{
const T* buffer = reinterpret_cast<const T*>(memory);
std::vector<T> vector(buffer, buffer + (size / sizeof(T)));
@@ -1635,7 +1659,7 @@
return fbVector;
}
-flatbuffers::Offset<TensorInfo> SerializerVisitor::CreateTensorInfo(const armnn::TensorInfo& tensorInfo)
+flatbuffers::Offset<TensorInfo> SerializerStrategy::CreateTensorInfo(const armnn::TensorInfo& tensorInfo)
{
// Get the dimensions
std::vector<unsigned int> shape;
@@ -1674,7 +1698,7 @@
}
flatbuffers::Offset<serializer::ConstTensor>
- SerializerVisitor::CreateConstTensorInfo(const armnn::ConstTensor& constTensor)
+ SerializerStrategy::CreateConstTensorInfo(const armnn::ConstTensor& constTensor)
{
armnn::TensorInfo tensorInfo = constTensor.GetInfo();
@@ -1724,7 +1748,7 @@
return flatBufferConstTensor;
}
-flatbuffers::Offset<armnnSerializer::FeatureCompatibilityVersions> SerializerVisitor::GetVersionTable()
+flatbuffers::Offset<armnnSerializer::FeatureCompatibilityVersions> SerializerStrategy::GetVersionTable()
{
flatbuffers::Offset<armnnSerializer::FeatureCompatibilityVersions> versionsTable =
serializer::CreateFeatureCompatibilityVersions(
@@ -1735,7 +1759,7 @@
}
std::vector<fb::Offset<serializer::InputSlot>>
- SerializerVisitor::CreateInputSlots(const armnn::IConnectableLayer* layer)
+ SerializerStrategy::CreateInputSlots(const armnn::IConnectableLayer* layer)
{
std::vector<fb::Offset<serializer::InputSlot>> inputSlots;
@@ -1757,7 +1781,7 @@
}
std::vector<fb::Offset<serializer::OutputSlot>>
- SerializerVisitor::CreateOutputSlots(const armnn::IConnectableLayer* layer)
+ SerializerStrategy::CreateOutputSlots(const armnn::IConnectableLayer* layer)
{
std::vector<fb::Offset<serializer::OutputSlot>> outputSlots;
@@ -1775,32 +1799,421 @@
return outputSlots;
}
+void SerializerStrategy::ExecuteStrategy(const armnn::IConnectableLayer* layer,
+ const BaseDescriptor& descriptor,
+ const std::vector<armnn::ConstTensor>& constants,
+ const char* name,
+ const armnn::LayerBindingId id)
+{
+ IgnoreUnused(constants);
+
+ switch (layer->GetType())
+ {
+ case armnn::LayerType::Activation :
+ {
+ const armnn::ActivationDescriptor& layerDescriptor =
+ static_cast<const armnn::ActivationDescriptor&>(descriptor);
+ SerializeActivationLayer(layer, layerDescriptor, name);
+ break;
+ }
+ case armnn::LayerType::Addition :
+ {
+ SerializeAdditionLayer(layer, name);
+ break;
+ }
+ case armnn::LayerType::ArgMinMax :
+ {
+ const armnn::ArgMinMaxDescriptor& layerDescriptor =
+ static_cast<const armnn::ArgMinMaxDescriptor&>(descriptor);
+ SerializeArgMinMaxLayer(layer, layerDescriptor, name);
+ break;
+ }
+ case armnn::LayerType::BatchNormalization :
+ {
+ const armnn::BatchNormalizationDescriptor& layerDescriptor =
+ static_cast<const armnn::BatchNormalizationDescriptor&>(descriptor);
+ SerializeBatchNormalizationLayer(layer,
+ layerDescriptor,
+ constants,
+ name);
+ break;
+ }
+ case armnn::LayerType::BatchToSpaceNd :
+ {
+ const armnn::BatchToSpaceNdDescriptor& layerDescriptor =
+ static_cast<const armnn::BatchToSpaceNdDescriptor&>(descriptor);
+ SerializeBatchToSpaceNdLayer(layer,
+ layerDescriptor,
+ name);
+ break;
+ }
+ case armnn::LayerType::Comparison :
+ {
+ const armnn::ComparisonDescriptor& layerDescriptor =
+ static_cast<const armnn::ComparisonDescriptor&>(descriptor);
+ SerializeComparisonLayer(layer,
+ layerDescriptor,
+ name);
+ break;
+ }
+ case armnn::LayerType::Concat :
+ {
+ const armnn::ConcatDescriptor& layerDescriptor =
+ static_cast<const armnn::ConcatDescriptor&>(descriptor);
+ SerializeConcatLayer(layer,
+ layerDescriptor,
+ name);
+ break;
+ }
+ case armnn::LayerType::Constant :
+ {
+ SerializeConstantLayer(layer,
+ constants,
+ name);
+ break;
+ }
+ case armnn::LayerType::Convolution2d :
+ {
+ const armnn::Convolution2dDescriptor& layerDescriptor =
+ static_cast<const armnn::Convolution2dDescriptor&>(descriptor);
+ SerializeConvolution2dLayer(layer,
+ layerDescriptor,
+ constants,
+ name);
+ break;
+ }
+ case armnn::LayerType::DepthToSpace :
+ {
+ const armnn::DepthToSpaceDescriptor& layerDescriptor =
+ static_cast<const armnn::DepthToSpaceDescriptor&>(descriptor);
+ SerializeDepthToSpaceLayer(layer,
+ layerDescriptor,
+ name);
+ break;
+ }
+ case armnn::LayerType::DepthwiseConvolution2d :
+ {
+ const armnn::DepthwiseConvolution2dDescriptor& layerDescriptor =
+ static_cast<const armnn::DepthwiseConvolution2dDescriptor&>(descriptor);
+ SerializeDepthwiseConvolution2dLayer(layer,
+ layerDescriptor,
+ constants,
+ name);
+ break;
+ }
+ case armnn::LayerType::Dequantize :
+ {
+ SerializeDequantizeLayer(layer,
+ name);
+ break;
+ }
+ case armnn::LayerType::DetectionPostProcess :
+ {
+ const armnn::DetectionPostProcessDescriptor& layerDescriptor =
+ static_cast<const armnn::DetectionPostProcessDescriptor&>(descriptor);
+ SerializeDetectionPostProcessLayer(layer, layerDescriptor, constants, name);
+ break;
+ }
+ case armnn::LayerType::Division :
+ {
+ SerializeDivisionLayer(layer, name);
+ break;
+ }
+ case armnn::LayerType::ElementwiseUnary :
+ {
+ const armnn::ElementwiseUnaryDescriptor& layerDescriptor =
+ static_cast<const armnn::ElementwiseUnaryDescriptor&>(descriptor);
+ SerializeElementwiseUnaryLayer(layer, layerDescriptor, name);
+ break;
+ }
+ case armnn::LayerType::Fill :
+ {
+ const armnn::FillDescriptor& layerDescriptor =
+ static_cast<const armnn::FillDescriptor&>(descriptor);
+ SerializeFillLayer(layer, layerDescriptor, name);
+ break;
+ }
+ case armnn::LayerType::Floor :
+ {
+ SerializeFloorLayer(layer, name);
+ break;
+ }
+ case armnn::LayerType::FullyConnected :
+ {
+ const armnn::FullyConnectedDescriptor& layerDescriptor =
+ static_cast<const armnn::FullyConnectedDescriptor&>(descriptor);
+ SerializeFullyConnectedLayer(layer, layerDescriptor, constants, name);
+ break;
+ }
+ case armnn::LayerType::Gather :
+ {
+ const armnn::GatherDescriptor& layerDescriptor =
+ static_cast<const armnn::GatherDescriptor&>(descriptor);
+ SerializeGatherLayer(layer, layerDescriptor, name);
+ break;
+ }
+ case armnn::LayerType::Input:
+ {
+ SerializeInputLayer(layer, id, name);
+ break;
+ }
+ case armnn::LayerType::InstanceNormalization :
+ {
+ const armnn::InstanceNormalizationDescriptor& layerDescriptor =
+ static_cast<const armnn::InstanceNormalizationDescriptor&>(descriptor);
+ SerializeInstanceNormalizationLayer(layer, layerDescriptor, name);
+ break;
+ }
+ case armnn::LayerType::L2Normalization :
+ {
+ const armnn::L2NormalizationDescriptor& layerDescriptor =
+ static_cast<const armnn::L2NormalizationDescriptor&>(descriptor);
+ SerializeL2NormalizationLayer(layer, layerDescriptor, name);
+ break;
+ }
+ case armnn::LayerType::LogicalBinary :
+ {
+ const armnn::LogicalBinaryDescriptor& layerDescriptor =
+ static_cast<const armnn::LogicalBinaryDescriptor&>(descriptor);
+ SerializeLogicalBinaryLayer(layer, layerDescriptor, name);
+ break;
+ }
+ case armnn::LayerType::LogSoftmax :
+ {
+ const armnn::LogSoftmaxDescriptor& layerDescriptor =
+ static_cast<const armnn::LogSoftmaxDescriptor&>(descriptor);
+ SerializeLogSoftmaxLayer(layer, layerDescriptor, name);
+ break;
+ }
+ case armnn::LayerType::Lstm :
+ {
+ const armnn::LstmDescriptor& layerDescriptor =
+ static_cast<const armnn::LstmDescriptor&>(descriptor);
+ SerializeLstmLayer(layer, layerDescriptor, constants, name);
+ break;
+ }
+ case armnn::LayerType::QLstm :
+ {
+ const armnn::QLstmDescriptor& layerDescriptor =
+ static_cast<const armnn::QLstmDescriptor&>(descriptor);
+ SerializeQLstmLayer(layer, layerDescriptor, constants, name);
+ break;
+ }
+ case armnn::LayerType::Maximum :
+ {
+ SerializeMaximumLayer(layer, name);
+ break;
+ }
+ case armnn::LayerType::Mean :
+ {
+ const armnn::MeanDescriptor& layerDescriptor =
+ static_cast<const armnn::MeanDescriptor&>(descriptor);
+ SerializeMeanLayer(layer, layerDescriptor, name);
+ break;
+ }
+ case armnn::LayerType::Merge :
+ {
+ SerializeMergeLayer(layer, name);
+ break;
+ }
+ case armnn::LayerType::Minimum :
+ {
+ SerializeMinimumLayer(layer, name);
+ break;
+ }
+ case armnn::LayerType::Multiplication :
+ {
+ SerializeMultiplicationLayer(layer, name);
+ break;
+ }
+ case armnn::LayerType::Normalization :
+ {
+ const armnn::NormalizationDescriptor& layerDescriptor =
+ static_cast<const armnn::NormalizationDescriptor&>(descriptor);
+ SerializeNormalizationLayer(layer, layerDescriptor, name);
+ break;
+ }
+ case armnn::LayerType::Output:
+ {
+ SerializeOutputLayer(layer, id, name);
+ break;
+ }
+ case armnn::LayerType::Pad :
+ {
+ const armnn::PadDescriptor& layerDescriptor =
+ static_cast<const armnn::PadDescriptor&>(descriptor);
+ SerializePadLayer(layer, layerDescriptor, name);
+ break;
+ }
+ case armnn::LayerType::Permute :
+ {
+ const armnn::PermuteDescriptor& layerDescriptor =
+ static_cast<const armnn::PermuteDescriptor&>(descriptor);
+ SerializePermuteLayer(layer, layerDescriptor, name);
+ break;
+ }
+ case armnn::LayerType::Pooling2d :
+ {
+ const armnn::Pooling2dDescriptor& layerDescriptor =
+ static_cast<const armnn::Pooling2dDescriptor&>(descriptor);
+ SerializePooling2dLayer(layer, layerDescriptor, name);
+ break;
+ }
+ case armnn::LayerType::Prelu :
+ {
+ SerializePreluLayer(layer, name);
+ break;
+ }
+ case armnn::LayerType::Quantize :
+ {
+ SerializeQuantizeLayer(layer, name);
+ break;
+ }
+ case armnn::LayerType::QuantizedLstm:
+ SerializeQuantizedLstmLayer(layer, constants, name);
+ break;
+ case armnn::LayerType::Reshape:
+ {
+ const armnn::ReshapeDescriptor &layerDescriptor =
+ static_cast<const armnn::ReshapeDescriptor &>(descriptor);
+ SerializeReshapeLayer(layer, layerDescriptor, name);
+ break;
+ }
+ case armnn::LayerType::Rank:
+ {
+ SerializeRankLayer(layer, name);
+ break;
+ }
+ case armnn::LayerType::Reduce:
+ {
+ const armnn::ReduceDescriptor& layerDescriptor =
+ static_cast<const armnn::ReduceDescriptor&>(descriptor);
+ SerializeReduceLayer(layer, layerDescriptor, name);
+ break;
+ }
+ case armnn::LayerType::Resize:
+ {
+ const armnn::ResizeDescriptor& layerDescriptor =
+ static_cast<const armnn::ResizeDescriptor&>(descriptor);
+ SerializeResizeLayer(layer, layerDescriptor, name);
+ break;
+ }
+ case armnn::LayerType::Slice:
+ {
+ const armnn::SliceDescriptor& layerDescriptor =
+ static_cast<const armnn::SliceDescriptor&>(descriptor);
+ SerializeSliceLayer(layer, layerDescriptor, name);
+ break;
+ }
+ case armnn::LayerType::Softmax:
+ {
+ const armnn::SoftmaxDescriptor& layerDescriptor =
+ static_cast<const armnn::SoftmaxDescriptor&>(descriptor);
+ SerializeSoftmaxLayer(layer, layerDescriptor, name);
+ break;
+ }
+ case armnn::LayerType::SpaceToBatchNd:
+ {
+ const armnn::SpaceToBatchNdDescriptor& layerDescriptor =
+ static_cast<const armnn::SpaceToBatchNdDescriptor&>(descriptor);
+ SerializeSpaceToBatchNdLayer(layer, layerDescriptor, name);
+ break;
+ }
+ case armnn::LayerType::SpaceToDepth:
+ {
+ const armnn::SpaceToDepthDescriptor& layerDescriptor =
+ static_cast<const armnn::SpaceToDepthDescriptor&>(descriptor);
+ SerializeSpaceToDepthLayer(layer, layerDescriptor, name);
+ break;
+ }
+ case armnn::LayerType::Splitter:
+ {
+ const armnn::SplitterDescriptor& layerDescriptor =
+ static_cast<const armnn::SplitterDescriptor&>(descriptor);
+ SerializeSplitterLayer(layer, layerDescriptor, name);
+ break;
+ }
+ case armnn::LayerType::Stack:
+ {
+ const armnn::StackDescriptor& layerDescriptor =
+ static_cast<const armnn::StackDescriptor&>(descriptor);
+ SerializeStackLayer(layer, layerDescriptor, name);
+ break;
+ }
+ case armnn::LayerType::StandIn:
+ {
+ const armnn::StandInDescriptor& layerDescriptor =
+ static_cast<const armnn::StandInDescriptor&>(descriptor);
+ SerializeStandInLayer(layer, layerDescriptor, name);
+ break;
+ }
+ case armnn::LayerType::StridedSlice:
+ {
+ const armnn::StridedSliceDescriptor& layerDescriptor =
+ static_cast<const armnn::StridedSliceDescriptor&>(descriptor);
+ SerializeStridedSliceLayer(layer, layerDescriptor, name);
+ break;
+ }
+ case armnn::LayerType::Subtraction:
+ {
+ SerializeSubtractionLayer(layer, name);
+ break;
+ }
+ case armnn::LayerType::Switch:
+ {
+ SerializeSwitchLayer(layer, name);
+ break;
+ }
+ case armnn::LayerType::Transpose:
+ {
+ const armnn::TransposeDescriptor& layerDescriptor =
+ static_cast<const armnn::TransposeDescriptor&>(descriptor);
+ SerializeTransposeLayer(layer, layerDescriptor, name);
+ break;
+ }
+ case armnn::LayerType::TransposeConvolution2d:
+ {
+ const armnn::TransposeConvolution2dDescriptor& layerDescriptor =
+ static_cast<const armnn::TransposeConvolution2dDescriptor&>(descriptor);
+ SerializeTransposeConvolution2dLayer(layer, layerDescriptor, constants, name);
+ break;
+ }
+ default:
+ {
+ throw InvalidArgumentException(
+ fmt::format("A layer of unknown type was given to the serializer. Layer name: {}; Layer Id: {}",
+ layer->GetName(),
+ id));
+ }
+ }
+}
+
void ISerializer::SerializerImpl::Serialize(const INetwork& inNetwork)
{
// Iterate through to network
- inNetwork.Accept(m_SerializerVisitor);
- flatbuffers::FlatBufferBuilder& fbBuilder = m_SerializerVisitor.GetFlatBufferBuilder();
+ inNetwork.ExecuteStrategy(m_SerializerStrategy);
+ flatbuffers::FlatBufferBuilder& fbBuilder = m_SerializerStrategy.GetFlatBufferBuilder();
// Create FlatBuffer SerializedGraph
auto serializedGraph = serializer::CreateSerializedGraph(
- fbBuilder,
- fbBuilder.CreateVector(m_SerializerVisitor.GetSerializedLayers()),
- fbBuilder.CreateVector(m_SerializerVisitor.GetInputIds()),
- fbBuilder.CreateVector(m_SerializerVisitor.GetOutputIds()),
- m_SerializerVisitor.GetVersionTable());
+ fbBuilder,
+ fbBuilder.CreateVector(m_SerializerStrategy.GetSerializedLayers()),
+ fbBuilder.CreateVector(m_SerializerStrategy.GetInputIds()),
+ fbBuilder.CreateVector(m_SerializerStrategy.GetOutputIds()),
+ m_SerializerStrategy.GetVersionTable());
// Serialize the graph
fbBuilder.Finish(serializedGraph);
}
+
bool ISerializer::SerializerImpl::SaveSerializedToStream(std::ostream& stream)
{
- flatbuffers::FlatBufferBuilder& fbBuilder = m_SerializerVisitor.GetFlatBufferBuilder();
+ flatbuffers::FlatBufferBuilder& fbBuilder = m_SerializerStrategy.GetFlatBufferBuilder();
auto bytesToWrite = armnn::numeric_cast<std::streamsize>(fbBuilder.GetSize());
stream.write(reinterpret_cast<const char*>(fbBuilder.GetBufferPointer()), bytesToWrite);
return !stream.bad();
}
-
} // namespace armnnSerializer