void DynamicQuantizationVisitor::VisitAdditionLayer(const IConnectableLayer* layer, const char* name)
{
+ boost::ignore_unused(name);
SetRange(layer, 0, -20.f, 20.f);
AddToCalibratedLayers(layer);
}
const ActivationDescriptor& activationDescriptor,
const char* name)
{
+ boost::ignore_unused(name, activationDescriptor);
switch (activationDescriptor.m_Function)
{
// Range is 0, 15 for Abs, Linear, ReLu and Soft ReLu
const ConcatDescriptor& originsDescriptor,
const char* name)
{
+ boost::ignore_unused(name);
+ boost::ignore_unused(originsDescriptor);
float min = std::numeric_limits<float>::max();
float max = std::numeric_limits<float>::lowest();
for (unsigned int i = 0; i < layer->GetNumInputSlots(); ++i)
#include "Layer.hpp"
#include <boost/assert.hpp>
+#include <boost/core/ignore_unused.hpp>
namespace armnn
{
void OverrideInputRangeVisitor::VisitInputLayer(const IConnectableLayer* layer, LayerBindingId id, const char* name)
{
+ boost::ignore_unused(name);
if (m_LayerId == id)
{
m_Ranges.SetRange(layer, 0, m_MinMaxRange.first, m_MinMaxRange.second);
void StaticRangeVisitor::VisitAdditionLayer(const IConnectableLayer* layer, const char* name)
{
+ boost::ignore_unused(name);
SetRange(layer, 0, -20.f, 20.f);
}
const ActivationDescriptor& activationDescriptor,
const char* name)
{
+ boost::ignore_unused(name);
switch (activationDescriptor.m_Function)
{
// Range is 0, 15 for Abs, Linear, ReLu and Soft ReLu
const char* name)
{
boost::ignore_unused(pooling2dDescriptor);
+ boost::ignore_unused(name);
ForwardParentParameters(layer);
}
const char* name)
{
boost::ignore_unused(softmaxDescriptor);
+ boost::ignore_unused(name);
SetRange(layer, 0, 0.f, 1.f);
}
const OriginsDescriptor& originsDescriptor,
const char* name)
{
+ boost::ignore_unused(originsDescriptor);
+ boost::ignore_unused(name);
float min = std::numeric_limits<float>::max();
float max = std::numeric_limits<float>::lowest();
for (unsigned int i = 0; i < layer->GetNumInputSlots(); ++i)
#include "../RangeTracker.hpp"
#include "../../armnnQuantizer/CommandLineProcessor.hpp"
+#include <boost/core/ignore_unused.hpp>
#include <boost/test/unit_test.hpp>
#include <unordered_map>
LayerBindingId id,
const char* name = nullptr) override
{
+ boost::ignore_unused(id, name);
const TensorInfo& info = layer->GetOutputSlot(0).GetTensorInfo();
BOOST_TEST(m_InputShape == info.GetShape());
// Based off current default [-15.0f, 15.0f]
LayerBindingId id,
const char* name = nullptr) override
{
+ boost::ignore_unused(id, name);
const TensorInfo& info = layer->GetInputSlot(0).GetConnection()->GetTensorInfo();
BOOST_TEST(m_OutputShape == info.GetShape());
}
const OffsetScalePair& params,
DataType dataType = DataType::QuantisedAsymm8)
{
+ boost::ignore_unused(dataType);
TestQuantizationParamsImpl(info, DataType::QuantisedAsymm8, params.first, params.second);
}
void VisitAdditionLayer(const IConnectableLayer* layer,
const char* name = nullptr) override
{
+ boost::ignore_unused(name);
TensorInfo info = layer->GetOutputSlot(0).GetTensorInfo();
// Based off default static range [-20.0f, 20.0f]
const ActivationDescriptor& descriptor,
const char* name = nullptr) override
{
+ boost::ignore_unused(descriptor, name);
+
TensorInfo info = layer->GetOutputSlot(0).GetTensorInfo();
// Based off default static range [0.0f, 15.0f]
LayerBindingId id,
const char* name = nullptr) override
{
+ boost::ignore_unused(id, name);
const TensorInfo& info = layer->GetInputSlot(0).GetConnection()->GetTensorInfo();
BOOST_CHECK_MESSAGE(info.GetDataType() == m_DataType,
std::string(armnn::GetDataTypeName(info.GetDataType()))
const ActivationDescriptor& descriptor,
const char* name = nullptr) override
{
+ boost::ignore_unused(descriptor, name);
TensorInfo info = layer->GetOutputSlot(0).GetTensorInfo();
// Based off default static range [0.0f, 3.5f]
const ActivationDescriptor& descriptor,
const char* name = nullptr) override
{
+ boost::ignore_unused(descriptor, name);
TensorInfo info = layer->GetOutputSlot(0).GetTensorInfo();
// Based off default static range [-1.0f, 1.0f]
const ActivationDescriptor& descriptor,
const char* name = nullptr) override
{
+ boost::ignore_unused(descriptor, name);
TensorInfo info = layer->GetOutputSlot(0).GetTensorInfo();
// Based off default static range [-5.0f, 15.0f]
const ConstTensor& gamma,
const char* name = nullptr) override
{
+ boost::ignore_unused(desc, name);
TensorInfo info = layer->GetOutputSlot(0).GetTensorInfo();
// Based off default static range [-15.0f, 15.0f]
const DepthToSpaceDescriptor& desc,
const char* name = nullptr)
{
+ boost::ignore_unused(desc, name);
const TensorInfo& info = layer->GetOutputSlot(0).GetTensorInfo();
const OffsetScalePair qAsymm8Params{ 30.0f / g_Asymm8QuantizationBase, 128 };
const Optional<ConstTensor>& biases,
const char* name = nullptr) override
{
+ boost::ignore_unused(desc, name);
TestQuantizationOnLayersWithBiases(layer, weights, biases);
}
};
const Optional<ConstTensor>& biases,
const char *name = nullptr) override
{
+ boost::ignore_unused(convolution2dDescriptor, name);
TestQuantizationOnLayersWithBiases(layer, weights, biases);
}
};
const Optional<ConstTensor>& biases,
const char *name = nullptr) override
{
+ boost::ignore_unused(convolution2dDescriptor, name);
TestQuantizationOnLayersWithBiases(layer, weights, biases);
}
};
const InstanceNormalizationDescriptor& descriptor,
const char* name = nullptr)
{
+ boost::ignore_unused(descriptor, name);
const TensorInfo& info = layer->GetOutputSlot(0).GetTensorInfo();
const OffsetScalePair qAsymm8Params{ 30.0f / g_Asymm8QuantizationBase, 128 };
const SoftmaxDescriptor& descriptor,
const char* name = nullptr) override
{
+ boost::ignore_unused(descriptor, name);
TensorInfo info = layer->GetOutputSlot(0).GetTensorInfo();
const OffsetScalePair qAsymm8Params{ 30.0f / g_Asymm8QuantizationBase, 128 };
const SoftmaxDescriptor& descriptor,
const char* name = nullptr) override
{
+ boost::ignore_unused(descriptor, name);
TensorInfo info = layer->GetOutputSlot(0).GetTensorInfo();
// Based off default static range [0.0f, 1.0f]
const PermuteDescriptor& desc,
const char* name = nullptr) override
{
+ boost::ignore_unused(desc, name);
CheckForwardedQuantizationSettings(layer);
}
};
const SpaceToBatchNdDescriptor& spaceToBatchNdDescriptor,
const char* name = nullptr) override
{
+ boost::ignore_unused(spaceToBatchNdDescriptor, name);
CheckForwardedQuantizationSettings(layer);
}
};
const Pooling2dDescriptor& desc,
const char* name = nullptr) override
{
+ boost::ignore_unused(desc, name);
CheckForwardedQuantizationSettings(layer);
}
};
const ConstTensor& input,
const char* name = nullptr) override
{
+ boost::ignore_unused(input, name);
TensorInfo info = layer->GetOutputSlot(0).GetTensorInfo();
// Based off the range of values in the const tensor used for the test: [-2.0f, 6.0f]
void VisitAbsLayer(const IConnectableLayer *layer,
const char *name = nullptr) override
{
+ boost::ignore_unused(name);
TensorInfo outputInfo = layer->GetOutputSlot(0).GetTensorInfo();
TestQuantizationParams(outputInfo,
void VisitInputLayer(const IConnectableLayer* layer,
LayerBindingId id,
const char* name = nullptr) override
- {}
+ {
+ boost::ignore_unused(layer, id, name);
+ }
void VisitOutputLayer(const IConnectableLayer* layer,
LayerBindingId id,
const char* name = nullptr) override
- {}
+ {
+ boost::ignore_unused(layer, id, name);
+ }
void VisitArgMinMaxLayer(const IConnectableLayer* layer,
const ArgMinMaxDescriptor& argMinMaxDescriptor,
const char* name = nullptr) override
{
+ boost::ignore_unused(argMinMaxDescriptor, name);
TensorInfo outputInfo = layer->GetOutputSlot(0).GetTensorInfo();
TestQuantizationParams(outputInfo,
const ComparisonDescriptor& descriptor,
const char* name = nullptr) override
{
+ boost::ignore_unused(descriptor, name);
TensorInfo info = layer->GetOutputSlot(0).GetTensorInfo();
const OffsetScalePair qAsymm8Params{ 30.0f / g_Asymm8QuantizationBase, 128 };
void VisitInputLayer(const IConnectableLayer* layer,
LayerBindingId id,
const char* name = nullptr) override
- {}
+ {
+ boost::ignore_unused(layer, id, name);
+ }
void VisitOutputLayer(const IConnectableLayer* layer,
LayerBindingId id,
const char* name = nullptr) override
- {}
+ {
+ boost::ignore_unused(layer, id, name);
+ }
void VisitConcatLayer(const IConnectableLayer* layer,
const OriginsDescriptor& originsDescriptor,
const char* name = nullptr) override
{
+ boost::ignore_unused(originsDescriptor, name);
TensorInfo outputInfo = layer->GetOutputSlot(0).GetTensorInfo();
TestQuantizationParams(
const ReshapeDescriptor& reshapeDescriptor,
const char* name = nullptr) override
{
+ boost::ignore_unused(reshapeDescriptor, name);
CheckForwardedQuantizationSettings(layer);
}
};
const SplitterDescriptor& desc,
const char* name = nullptr)
{
+ boost::ignore_unused(desc, name);
CheckForwardedQuantizationSettings(layer);
}
};
const ResizeDescriptor& resizeDescriptor,
const char* name = nullptr) override
{
+ boost::ignore_unused(resizeDescriptor, name);
CheckForwardedQuantizationSettings(layer);
}
};
const StridedSliceDescriptor& desc,
const char* name = nullptr)
{
+ boost::ignore_unused(desc, name);
CheckForwardedQuantizationSettings(layer);
}
};
const BatchToSpaceNdDescriptor& batchToSpaceNdDescriptor,
const char* name = nullptr) override
{
+ boost::ignore_unused(batchToSpaceNdDescriptor, name);
CheckForwardedQuantizationSettings(layer);
}
};
LayerBindingId id,
const char* name = nullptr) override
{
+ boost::ignore_unused(id, name);
const TensorInfo& info = layer->GetOutputSlot(0).GetTensorInfo();
switch (id)
LayerBindingId id,
const char* name = nullptr) override
{
+ boost::ignore_unused(id, name);
const TensorInfo& info = layer->GetInputSlot(0).GetConnection()->GetTensorInfo();
BOOST_TEST(m_OutputShape == info.GetShape());
}
void VisitPreluLayer(const IConnectableLayer* layer,
const char* name = nullptr) override
{
+ boost::ignore_unused(name);
const TensorInfo& info = layer->GetOutputSlot(0).GetTensorInfo();
TestQuantizationParams(info,
{ 30.0f / g_Asymm8QuantizationBase, 128 }, // QASymm8
const Optional<ConstTensor>& biases,
const char *name = nullptr) override
{
+ boost::ignore_unused(descriptor, name);
TestQuantizationOnLayersWithBiases(layer, weights, biases);
}
};
void VisitInputLayer(const IConnectableLayer* layer,
LayerBindingId id,
const char* name = nullptr) override
- {}
+ {
+ boost::ignore_unused(layer, id, name);
+ }
void VisitOutputLayer(const IConnectableLayer* layer,
LayerBindingId id,
const char* name = nullptr) override
- {}
+ {
+ boost::ignore_unused(layer, id, name);
+ }
void VisitStackLayer(const IConnectableLayer* layer,
const StackDescriptor& descriptor,
const char* name = nullptr) override
{
+ boost::ignore_unused(descriptor, name);
TensorInfo outputInfo = layer->GetOutputSlot(0).GetTensorInfo();
TestQuantizationParams(outputInfo,
const SliceDescriptor& desc,
const char* name = nullptr)
{
+ boost::ignore_unused(desc, name);
const TensorInfo& info = layer->GetOutputSlot(0).GetTensorInfo();
const OffsetScalePair qAsymm8Params{ 30.0f / g_Asymm8QuantizationBase, 128 };
LayerBindingId id,
const char* name = nullptr) override
{
+ boost::ignore_unused(id, name);
const TensorInfo& info = layer->GetOutputSlot(0).GetTensorInfo();
BOOST_TEST(GetDataTypeName(info.GetDataType()) == GetDataTypeName(m_DataType));
BOOST_TEST(m_InputShape == info.GetShape());
LayerBindingId id,
const char* name = nullptr) override
{
+ boost::ignore_unused(id, name);
const TensorInfo& info = layer->GetInputSlot(0).GetConnection()->GetTensorInfo();
BOOST_TEST(GetDataTypeName(info.GetDataType()) == GetDataTypeName(m_DataType));
BOOST_TEST(m_OutputShape == info.GetShape());
void VisitQuantizeLayer(const IConnectableLayer* layer,
const char* name = nullptr) override
{
+ boost::ignore_unused(layer, name);
m_VisitedQuantizeLayer = true;
}
void VisitDequantizeLayer(const IConnectableLayer* layer,
const char* name = nullptr) override
{
+ boost::ignore_unused(layer, name);
m_VisitedDequantizeLayer = true;
}
BindingPointInfo Deserializer::GetNetworkInputBindingInfo(unsigned int layerIndex,
const std::string& name) const
{
+ boost::ignore_unused(layerIndex);
for (auto inputBinding : m_InputBindings)
{
if (inputBinding.first == name)
BindingPointInfo Deserializer::GetNetworkOutputBindingInfo(unsigned int layerIndex,
const std::string& name) const
{
+ boost::ignore_unused(layerIndex);
for (auto outputBinding : m_OutputBindings)
{
if (outputBinding.first == name)
armnn::Pooling2dDescriptor Deserializer::GetPoolingDescriptor(Deserializer::PoolingDescriptor pooling2dDesc,
unsigned int layerIndex)
{
+ boost::ignore_unused(layerIndex);
armnn::Pooling2dDescriptor desc;
switch (pooling2dDesc->poolType())
Deserializer::NormalizationDescriptorPtr normalizationDescriptor,
unsigned int layerIndex)
{
+ boost::ignore_unused(layerIndex);
armnn::NormalizationDescriptor desc;
switch (normalizationDescriptor->normChannelType())
#include "ParserFlatbuffersSerializeFixture.hpp"
#include "../Deserializer.hpp"
+#include <boost/core/ignore_unused.hpp>
+
#include <string>
#include <iostream>
const std::string & dataType,
const std::string & activation="NONE")
{
+ boost::ignore_unused(activation);
m_JsonString = R"(
{
inputIds: [0, 1],
#include "ParserFlatbuffersSerializeFixture.hpp"
#include "../Deserializer.hpp"
+#include <boost/core/ignore_unused.hpp>
+
#include <string>
#include <iostream>
const std::string & dataType,
const std::string & activation="NONE")
{
+ boost::ignore_unused(activation);
m_JsonString = R"(
{
inputIds: [0, 1],
#include <armnn/IRuntime.hpp>
#include <armnnDeserializer/IDeserializer.hpp>
+#include <boost/core/ignore_unused.hpp>
#include <boost/assert.hpp>
#include <boost/format.hpp>
armnnSerializer::TensorInfo tensorType, const std::string& name,
const float scale, const int64_t zeroPoint)
{
+ boost::ignore_unused(name);
BOOST_CHECK_EQUAL(shapeSize, tensors->dimensions()->size());
BOOST_CHECK_EQUAL_COLLECTIONS(shape.begin(), shape.end(),
tensors->dimensions()->begin(), tensors->dimensions()->end());
#define BOOST_FILESYSTEM_NO_DEPRECATED
+#include <boost/core/ignore_unused.hpp>
#include <boost/filesystem/operations.hpp>
#include <boost/filesystem/path.hpp>
armnn::LayerBindingId id,
const char* name)
{
+ boost::ignore_unused(name);
m_TensorInfos.emplace(id, layer->GetOutputSlot(0).GetTensorInfo());
}
#include <iostream>
+#include <boost/core/ignore_unused.hpp>
#include <boost/numeric/conversion/cast.hpp>
#include <flatbuffers/util.h>
// Build FlatBuffer for Input Layer
void SerializerVisitor::VisitInputLayer(const armnn::IConnectableLayer* layer, LayerBindingId id, const char* name)
{
+ boost::ignore_unused(name);
+
// Create FlatBuffer BaseLayer
auto flatBufferInputBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Input);
// Build FlatBuffer for Output Layer
void SerializerVisitor::VisitOutputLayer(const armnn::IConnectableLayer* layer, LayerBindingId id, const char* name)
{
+ boost::ignore_unused(name);
+
// Create FlatBuffer BaseLayer
auto flatBufferOutputBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Output);
void SerializerVisitor::VisitAbsLayer(const armnn::IConnectableLayer* layer, const char* name)
{
+ boost::ignore_unused(name);
auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Abs);
auto flatBufferAbsLayer = serializer::CreateAbsLayer(m_flatBufferBuilder, flatBufferBaseLayer);
const armnn::ActivationDescriptor& descriptor,
const char* name)
{
+ boost::ignore_unused(name);
+
// Create FlatBuffer BaseLayer
auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Activation);
// Build FlatBuffer for Addition Layer
void SerializerVisitor::VisitAdditionLayer(const armnn::IConnectableLayer* layer, const char* name)
{
+ boost::ignore_unused(name);
+
// Create FlatBuffer BaseLayer
auto flatBufferAdditionBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Addition);
const armnn::ArgMinMaxDescriptor& descriptor,
const char *name)
{
+ boost::ignore_unused(name);
+
// Create FlatBuffer BaseLayer
auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_ArgMinMax);
const armnn::BatchToSpaceNdDescriptor& descriptor,
const char* name)
{
+ boost::ignore_unused(name);
+
// Create FlatBuffer BaseLayer
auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_BatchToSpaceNd);
const armnn::ConstTensor& gamma,
const char* name)
{
+ boost::ignore_unused(name);
+
auto fbBatchNormalizationBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_BatchNormalization);
auto fbBatchNormalizationDescriptor = serializer::CreateBatchNormalizationDescriptor(
m_flatBufferBuilder,
const armnn::ComparisonDescriptor& descriptor,
const char* name)
{
+ boost::ignore_unused(name);
+
auto fbBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Comparison);
auto fbDescriptor = serializer::CreateComparisonDescriptor(
m_flatBufferBuilder,
const armnn::ConstTensor& input,
const char* name)
{
+ boost::ignore_unused(name);
+
// Create FlatBuffer BaseLayer
auto flatBufferConstantBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Constant);
const armnn::Optional<armnn::ConstTensor>& biases,
const char* name)
{
+ boost::ignore_unused(name);
+
// Create FlatBuffer BaseLayer
auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Convolution2d);
const armnn::DepthToSpaceDescriptor& descriptor,
const char* name)
{
+ boost::ignore_unused(name);
+
auto fbBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_DepthToSpace);
auto fbDescriptor = CreateDepthToSpaceDescriptor(m_flatBufferBuilder,
descriptor.m_BlockSize,
const armnn::Optional<armnn::ConstTensor>& biases,
const char* name)
{
+ boost::ignore_unused(name);
+
auto fbBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_DepthwiseConvolution2d);
auto fbDescriptor = CreateDepthwiseConvolution2dDescriptor(m_flatBufferBuilder,
descriptor.m_PadLeft,
void SerializerVisitor::VisitDequantizeLayer(const armnn::IConnectableLayer* layer,
const char* name)
{
+ boost::ignore_unused(name);
+
auto fbDequantizeBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Dequantize);
auto fbDequantizeLayer = serializer::CreateDequantizeLayer(m_flatBufferBuilder, fbDequantizeBaseLayer);
const armnn::ConstTensor& anchors,
const char* name)
{
+ boost::ignore_unused(name);
+
auto fbBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_DetectionPostProcess);
auto fbDescriptor = CreateDetectionPostProcessDescriptor(m_flatBufferBuilder,
descriptor.m_MaxDetections,
void SerializerVisitor::VisitDivisionLayer(const armnn::IConnectableLayer* layer, const char* name)
{
+ boost::ignore_unused(name);
+
auto fbDivisionBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Division);
auto fbDivisionLayer = serializer::CreateDivisionLayer(m_flatBufferBuilder, fbDivisionBaseLayer);
void SerializerVisitor::VisitEqualLayer(const armnn::IConnectableLayer* layer, const char* name)
{
+ boost::ignore_unused(name);
+
auto fbBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Equal);
auto fbEqualLayer = serializer::CreateEqualLayer(m_flatBufferBuilder, fbBaseLayer);
void SerializerVisitor::VisitFloorLayer(const armnn::IConnectableLayer *layer, const char *name)
{
+ boost::ignore_unused(name);
+
auto flatBufferFloorBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Floor);
auto flatBufferFloorLayer = serializer::CreateFloorLayer(m_flatBufferBuilder, flatBufferFloorBaseLayer);
void SerializerVisitor::VisitGatherLayer(const armnn::IConnectableLayer* layer, const char* name)
{
+ boost::ignore_unused(name);
+
auto fbGatherBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Gather);
auto flatBufferLayer = serializer::CreateGatherLayer(m_flatBufferBuilder, fbGatherBaseLayer);
void SerializerVisitor::VisitGreaterLayer(const armnn::IConnectableLayer* layer, const char* name)
{
+ boost::ignore_unused(name);
+
auto fbGreaterBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Greater);
auto fbGreaterLayer = serializer::CreateGreaterLayer(m_flatBufferBuilder, fbGreaterBaseLayer);
const armnn::InstanceNormalizationDescriptor& instanceNormalizationDescriptor,
const char* name)
{
+ boost::ignore_unused(name);
+
auto fbDescriptor = serializer::CreateInstanceNormalizationDescriptor(
m_flatBufferBuilder,
instanceNormalizationDescriptor.m_Gamma,
const armnn::L2NormalizationDescriptor& l2NormalizationDescriptor,
const char* name)
{
+ boost::ignore_unused(name);
+
// Create FlatBuffer BaseLayer
auto fbBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_L2Normalization);
const armnn::LogSoftmaxDescriptor& logSoftmaxDescriptor,
const char* name)
{
+ boost::ignore_unused(name);
+
// Create FlatBuffer BaseLayer
auto flatBufferLogSoftmaxBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_LogSoftmax);
const armnn::LstmInputParams& params,
const char* name)
{
+ boost::ignore_unused(name);
+
auto fbLstmBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Lstm);
auto fbLstmDescriptor = serializer::CreateLstmDescriptor(
void SerializerVisitor::VisitMaximumLayer(const armnn::IConnectableLayer* layer, const char* name)
{
+ boost::ignore_unused(name);
+
auto fbMaximumBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Maximum);
auto fbMaximumLayer = serializer::CreateMaximumLayer(m_flatBufferBuilder, fbMaximumBaseLayer);
const armnn::MeanDescriptor& descriptor,
const char* name)
{
+ boost::ignore_unused(name);
+
auto fbMeanBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Mean);
auto fbMeanDescriptor = serializer::CreateMeanDescriptor(m_flatBufferBuilder,
m_flatBufferBuilder.CreateVector(descriptor.m_Axis),
void SerializerVisitor::VisitMinimumLayer(const armnn::IConnectableLayer* layer, const char* name)
{
+ boost::ignore_unused(name);
+
auto fbMinimumBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Minimum);
auto fbMinimumLayer = serializer::CreateMinimumLayer(m_flatBufferBuilder, fbMinimumBaseLayer);
void SerializerVisitor::VisitMergeLayer(const armnn::IConnectableLayer* layer, const char* name)
{
+ boost::ignore_unused(name);
+
auto fbMergeBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Merge);
auto fbMergeLayer = serializer::CreateMergeLayer(m_flatBufferBuilder, fbMergeBaseLayer);
const armnn::ConcatDescriptor& concatDescriptor,
const char* name)
{
+ boost::ignore_unused(name);
+
auto flatBufferConcatBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Concat);
std::vector<flatbuffers::Offset<UintVector>> views;
void SerializerVisitor::VisitMultiplicationLayer(const armnn::IConnectableLayer* layer, const char* name)
{
+ boost::ignore_unused(name);
+
auto fbMultiplicationBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Multiplication);
auto fbMultiplicationLayer = serializer::CreateMultiplicationLayer(m_flatBufferBuilder,
fbMultiplicationBaseLayer);
const armnn::PadDescriptor& padDescriptor,
const char* name)
{
+ boost::ignore_unused(name);
+
auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Pad);
std::vector<unsigned int> padList;
const armnn::PermuteDescriptor& permuteDescriptor,
const char* name)
{
+ boost::ignore_unused(name);
+
// Create FlatBuffer BaseLayer
auto flatBufferPermuteBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Permute);
const armnn::ReshapeDescriptor& reshapeDescriptor,
const char* name)
{
+ boost::ignore_unused(name);
+
// Create FlatBuffer BaseLayer
auto flatBufferReshapeBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Reshape);
const armnn::ResizeBilinearDescriptor& resizeDescriptor,
const char* name)
{
+ boost::ignore_unused(name);
+
auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_ResizeBilinear);
auto flatBufferDescriptor =
const armnn::ResizeDescriptor& resizeDescriptor,
const char* name)
{
+ boost::ignore_unused(name);
+
auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Resize);
auto flatBufferDescriptor =
void SerializerVisitor::VisitRsqrtLayer(const armnn::IConnectableLayer* layer, const char* name)
{
+ boost::ignore_unused(name);
+
auto fbRsqrtBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Rsqrt);
auto fbRsqrtLayer = serializer::CreateRsqrtLayer(m_flatBufferBuilder, fbRsqrtBaseLayer);
const armnn::SliceDescriptor& sliceDescriptor,
const char* name)
{
+ boost::ignore_unused(name);
+
auto fbSliceBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Slice);
auto fbSliceDescriptor = CreateSliceDescriptor(m_flatBufferBuilder,
m_flatBufferBuilder.CreateVector(sliceDescriptor.m_Begin),
const armnn::SoftmaxDescriptor& softmaxDescriptor,
const char* name)
{
+ boost::ignore_unused(name);
+
// Create FlatBuffer BaseLayer
auto flatBufferSoftmaxBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Softmax);
const armnn::Pooling2dDescriptor& pooling2dDescriptor,
const char* name)
{
+ boost::ignore_unused(name);
+
auto fbPooling2dBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Pooling2d);
auto fbPooling2dDescriptor = serializer::CreatePooling2dDescriptor(
m_flatBufferBuilder,
void SerializerVisitor::VisitPreluLayer(const armnn::IConnectableLayer* layer,
const char* name)
{
+ boost::ignore_unused(name);
+
// Create FlatBuffer BaseLayer
auto flatBufferPreluBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Prelu);
void SerializerVisitor::VisitQuantizeLayer(const armnn::IConnectableLayer *layer, const char *name)
{
+ boost::ignore_unused(name);
+
auto fbQuantizeBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Quantize);
auto fbQuantizeLayer = serializer::CreateQuantizeLayer(m_flatBufferBuilder,
fbQuantizeBaseLayer);
const armnn::Optional<armnn::ConstTensor>& biases,
const char* name)
{
+ boost::ignore_unused(name);
+
// Create FlatBuffer BaseLayer
auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_FullyConnected);
const armnn::SpaceToBatchNdDescriptor& spaceToBatchNdDescriptor,
const char* name)
{
+ boost::ignore_unused(name);
+
// Create FlatBuffer BaseLayer
auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_SpaceToBatchNd);
const armnn::SpaceToDepthDescriptor& spaceToDepthDescriptor,
const char* name)
{
+ boost::ignore_unused(name);
+
auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_SpaceToDepth);
auto flatBufferDescriptor =
CreateSpaceToDepthDescriptor(m_flatBufferBuilder,
const armnn::ViewsDescriptor& viewsDescriptor,
const char* name)
{
+ boost::ignore_unused(name);
+
// Create FlatBuffer ViewOrigins
std::vector<flatbuffers::Offset<UintVector>> flatBufferViewOrigins;
flatBufferViewOrigins.reserve(viewsDescriptor.GetNumViews());
const armnn::NormalizationDescriptor& descriptor,
const char* name)
{
+ boost::ignore_unused(name);
+
auto fbNormalizationBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Normalization);
auto fbNormalizationDescriptor = serializer::CreateNormalizationDescriptor(
const armnn::StackDescriptor& stackDescriptor,
const char* name)
{
+ boost::ignore_unused(name);
+
auto stackBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Stack);
std::vector<unsigned int> inputShape;
const armnn::StandInDescriptor& standInDescriptor,
const char *name)
{
+ boost::ignore_unused(name);
+
auto fbDescriptor = serializer::CreateStandInDescriptor(m_flatBufferBuilder,
standInDescriptor.m_NumInputs,
standInDescriptor.m_NumOutputs);
const armnn::StridedSliceDescriptor& stridedSliceDescriptor,
const char* name)
{
+ boost::ignore_unused(name);
+
auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_StridedSlice);
auto flatBufferDescriptor =
void SerializerVisitor::VisitSubtractionLayer(const armnn::IConnectableLayer* layer, const char* name)
{
+ boost::ignore_unused(name);
+
auto fbSubtractionBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Subtraction);
auto fbSubtractionLayer = serializer::CreateSubtractionLayer(m_flatBufferBuilder, fbSubtractionBaseLayer);
void SerializerVisitor::VisitSwitchLayer(const armnn::IConnectableLayer* layer, const char* name)
{
+ boost::ignore_unused(name);
+
auto fbSwitchBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Switch);
auto fbSwitchLayer = serializer::CreateSwitchLayer(m_flatBufferBuilder, fbSwitchBaseLayer);
const armnn::Optional<armnn::ConstTensor>& biases,
const char* name)
{
+ boost::ignore_unused(name);
+
auto fbBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Convolution2d);
auto fbDescriptor = CreateTransposeConvolution2dDescriptor(m_flatBufferBuilder,
descriptor.m_PadLeft,
const armnn::QuantizedLstmInputParams& params,
const char* name)
{
+ boost::ignore_unused(name);
+
auto fbQuantizedLstmBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_QuantizedLstm);
// Get input parameters
fb::Offset<serializer::LayerBase> SerializerVisitor::CreateLayerBase(const IConnectableLayer* layer,
const serializer::LayerType layerType)
{
+
uint32_t fbIndex = GetSerializedId(layer->GetGuid());
std::vector<fb::Offset<serializer::InputSlot>> inputSlots = CreateInputSlots(layer);
void SerializerVisitor::CreateAnyLayer(const flatbuffers::Offset<void>& layer, const serializer::Layer serializerLayer)
{
+
auto anyLayer = armnnSerializer::CreateAnyLayer(m_flatBufferBuilder, serializerLayer, layer);
m_serializedLayers.push_back(anyLayer);
}
#include <armnn/INetwork.hpp>
#include "../Serializer.hpp"
#include <sstream>
+
+#include <boost/core/ignore_unused.hpp>
#include <boost/test/unit_test.hpp>
BOOST_AUTO_TEST_SUITE(SerializerTests)
const armnn::ActivationDescriptor& activationDescriptor,
const char* name) override
{
+ boost::ignore_unused(layer, activationDescriptor);
BOOST_TEST(name == "activation");
}
};
struct DefaultLayerVerifierPolicy
{
- static void Apply(const std::string s = "")
+ static void Apply(const std::string)
{
BOOST_TEST_MESSAGE("Unexpected layer found in network");
BOOST_TEST(false);
void VisitInputLayer(const armnn::IConnectableLayer*, armnn::LayerBindingId, const char*) override {}
- void VisitOutputLayer(const armnn::IConnectableLayer*, armnn::LayerBindingId id, const char*) override {}
+ void VisitOutputLayer(const armnn::IConnectableLayer*, armnn::LayerBindingId, const char*) override {}
protected:
void VerifyNameAndConnections(const armnn::IConnectableLayer* layer, const char* name)
CompareConstTensor(input, m_LayerInput);
}
- void VisitAdditionLayer(const armnn::IConnectableLayer* layer, const char* name = nullptr) override {}
+ void VisitAdditionLayer(const armnn::IConnectableLayer*, const char*) override {}
private:
armnn::ConstTensor m_LayerInput;
BOOST_CHECK(descriptor.m_Operation == armnn::ComparisonOperation::Equal);
}
- void VisitEqualLayer(const armnn::IConnectableLayer* layer, const char* name) override
+ void VisitEqualLayer(const armnn::IConnectableLayer*, const char*) override
{
throw armnn::Exception("EqualLayer should have translated to ComparisonLayer");
}
VerifyNameAndConnections(layer, name);
}
- void VisitConstantLayer(const armnn::IConnectableLayer* layer,
- const armnn::ConstTensor& input,
- const char *name) override {}
+ void VisitConstantLayer(const armnn::IConnectableLayer*,
+ const armnn::ConstTensor&,
+ const char*) override {}
};
const std::string layerName("gather");
BOOST_CHECK(descriptor.m_Operation == armnn::ComparisonOperation::Greater);
}
- void VisitGreaterLayer(const armnn::IConnectableLayer* layer, const char* name) override
+ void VisitGreaterLayer(const armnn::IConnectableLayer*, const char*) override
{
throw armnn::Exception("GreaterLayer should have translated to ComparisonLayer");
}
const armnn::OriginsDescriptor& descriptor)
: LayerVerifierBaseWithDescriptor<armnn::OriginsDescriptor>(layerName, inputInfos, outputInfos, descriptor) {}
- void VisitMergerLayer(const armnn::IConnectableLayer* layer,
- const armnn::OriginsDescriptor& descriptor,
- const char* name) override
+ void VisitMergerLayer(const armnn::IConnectableLayer*,
+ const armnn::OriginsDescriptor&,
+ const char*) override
{
throw armnn::Exception("MergerLayer should have translated to ConcatLayer");
}
VerifyNameAndConnections(layer, name);
}
- void VisitConstantLayer(const armnn::IConnectableLayer* layer,
- const armnn::ConstTensor& input,
- const char *name) override {}
+ void VisitConstantLayer(const armnn::IConnectableLayer*,
+ const armnn::ConstTensor&,
+ const char*) override {}
};
const std::string layerName("switch");
CompareConstTensor(input, m_LayerInput);
}
- void VisitAdditionLayer(const armnn::IConnectableLayer* layer, const char* name = nullptr) override {}
+ void VisitAdditionLayer(const armnn::IConnectableLayer*, const char*) override {}
private:
armnn::ConstTensor m_LayerInput;