IVGCVSW-4246 Clean build of Visitors with -Wextra

Change-Id: Icb1b35ff55fa22103777853e6f49fc282d61750d
Signed-off-by: Derek Lamberti <derek.lamberti@arm.com>

1 files changed, 108 insertions, 0 deletions

diff --git a/src/armnnSerializer/Serializer.cpp b/src/armnnSerializer/Serializer.cpp
index 5d06958054..608a9c3480 100644
--- a/src/armnnSerializer/Serializer.cpp
+++ b/src/armnnSerializer/Serializer.cpp
@@ -11,6 +11,7 @@
 
 #include <iostream>
 
+#include <boost/core/ignore_unused.hpp>
 #include <boost/numeric/conversion/cast.hpp>
 
 #include <flatbuffers/util.h>
@@ -80,6 +81,8 @@ uint32_t SerializerVisitor::GetSerializedId(armnn::LayerGuid guid)
 // 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);
 
@@ -100,6 +103,8 @@ void SerializerVisitor::VisitInputLayer(const armnn::IConnectableLayer* layer, L
 // 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);
 
@@ -118,6 +123,7 @@ void SerializerVisitor::VisitOutputLayer(const armnn::IConnectableLayer* layer,
 
 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);
 
@@ -129,6 +135,8 @@ void SerializerVisitor::VisitActivationLayer(const armnn::IConnectableLayer* lay
                                              const armnn::ActivationDescriptor& descriptor,
                                              const char* name)
 {
+    boost::ignore_unused(name);
+
     // Create FlatBuffer BaseLayer
     auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Activation);
 
@@ -150,6 +158,8 @@ void SerializerVisitor::VisitActivationLayer(const armnn::IConnectableLayer* lay
 // 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);
 
@@ -165,6 +175,8 @@ void SerializerVisitor::VisitArgMinMaxLayer(const armnn::IConnectableLayer *laye
                                             const armnn::ArgMinMaxDescriptor& descriptor,
                                             const char *name)
 {
+    boost::ignore_unused(name);
+
     // Create FlatBuffer BaseLayer
     auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_ArgMinMax);
 
@@ -186,6 +198,8 @@ void SerializerVisitor::VisitBatchToSpaceNdLayer(const armnn::IConnectableLayer*
                                                  const armnn::BatchToSpaceNdDescriptor& descriptor,
                                                  const char* name)
 {
+    boost::ignore_unused(name);
+
     // Create FlatBuffer BaseLayer
     auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_BatchToSpaceNd);
 
@@ -218,6 +232,8 @@ void SerializerVisitor::VisitBatchNormalizationLayer(const armnn::IConnectableLa
                                                      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,
@@ -243,6 +259,8 @@ void SerializerVisitor::VisitComparisonLayer(const armnn::IConnectableLayer* lay
                                              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,
@@ -257,6 +275,8 @@ void SerializerVisitor::VisitConstantLayer(const armnn::IConnectableLayer* layer
                                            const armnn::ConstTensor& input,
                                            const char* name)
 {
+    boost::ignore_unused(name);
+
     // Create FlatBuffer BaseLayer
     auto flatBufferConstantBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Constant);
 
@@ -278,6 +298,8 @@ void SerializerVisitor::VisitConvolution2dLayer(const armnn::IConnectableLayer*
                                                 const armnn::Optional<armnn::ConstTensor>& biases,
                                                 const char* name)
 {
+    boost::ignore_unused(name);
+
     // Create FlatBuffer BaseLayer
     auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Convolution2d);
 
@@ -315,6 +337,8 @@ void SerializerVisitor::VisitDepthToSpaceLayer(const armnn::IConnectableLayer* l
                                                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,
@@ -331,6 +355,8 @@ void SerializerVisitor::VisitDepthwiseConvolution2dLayer(const armnn::IConnectab
                                                          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,
@@ -363,6 +389,8 @@ void SerializerVisitor::VisitDepthwiseConvolution2dLayer(const armnn::IConnectab
 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);
 
@@ -374,6 +402,8 @@ void SerializerVisitor::VisitDetectionPostProcessLayer(const armnn::IConnectable
                                                        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,
@@ -400,6 +430,8 @@ void SerializerVisitor::VisitDetectionPostProcessLayer(const armnn::IConnectable
 
 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);
 
@@ -408,6 +440,8 @@ void SerializerVisitor::VisitDivisionLayer(const armnn::IConnectableLayer* layer
 
 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);
 
@@ -416,6 +450,8 @@ void SerializerVisitor::VisitEqualLayer(const armnn::IConnectableLayer* layer, c
 
 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);
 
@@ -424,6 +460,8 @@ void SerializerVisitor::VisitFloorLayer(const armnn::IConnectableLayer *layer, c
 
 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);
 
@@ -432,6 +470,8 @@ void SerializerVisitor::VisitGatherLayer(const armnn::IConnectableLayer* layer,
 
 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);
 
@@ -443,6 +483,8 @@ void SerializerVisitor::VisitInstanceNormalizationLayer(
     const armnn::InstanceNormalizationDescriptor& instanceNormalizationDescriptor,
     const char* name)
 {
+    boost::ignore_unused(name);
+
     auto fbDescriptor = serializer::CreateInstanceNormalizationDescriptor(
             m_flatBufferBuilder,
             instanceNormalizationDescriptor.m_Gamma,
@@ -460,6 +502,8 @@ void SerializerVisitor::VisitL2NormalizationLayer(const armnn::IConnectableLayer
                                                   const armnn::L2NormalizationDescriptor& l2NormalizationDescriptor,
                                                   const char* name)
 {
+    boost::ignore_unused(name);
+
     // Create FlatBuffer BaseLayer
     auto fbBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_L2Normalization);
 
@@ -479,6 +523,8 @@ void SerializerVisitor::VisitLogSoftmaxLayer(const armnn::IConnectableLayer* lay
                                              const armnn::LogSoftmaxDescriptor& logSoftmaxDescriptor,
                                              const char* name)
 {
+    boost::ignore_unused(name);
+
     // Create FlatBuffer BaseLayer
     auto flatBufferLogSoftmaxBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_LogSoftmax);
 
@@ -502,6 +548,8 @@ void SerializerVisitor::VisitLstmLayer(const armnn::IConnectableLayer* layer,
                                        const armnn::LstmInputParams& params,
                                        const char* name)
 {
+    boost::ignore_unused(name);
+
     auto fbLstmBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Lstm);
 
     auto fbLstmDescriptor = serializer::CreateLstmDescriptor(
@@ -605,6 +653,8 @@ void SerializerVisitor::VisitLstmLayer(const armnn::IConnectableLayer* layer,
 
 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);
 
@@ -615,6 +665,8 @@ void SerializerVisitor::VisitMeanLayer(const armnn::IConnectableLayer* layer,
                                        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),
@@ -629,6 +681,8 @@ void SerializerVisitor::VisitMeanLayer(const armnn::IConnectableLayer* layer,
 
 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);
 
@@ -637,6 +691,8 @@ void SerializerVisitor::VisitMinimumLayer(const armnn::IConnectableLayer* layer,
 
 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);
 
@@ -654,6 +710,8 @@ void SerializerVisitor::VisitConcatLayer(const armnn::IConnectableLayer* layer,
                                          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;
@@ -685,6 +743,8 @@ void SerializerVisitor::VisitConcatLayer(const armnn::IConnectableLayer* layer,
 
 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);
@@ -696,6 +756,8 @@ void SerializerVisitor::VisitPadLayer(const armnn::IConnectableLayer* layer,
                                       const armnn::PadDescriptor& padDescriptor,
                                       const char* name)
 {
+    boost::ignore_unused(name);
+
     auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Pad);
 
     std::vector<unsigned int> padList;
@@ -720,6 +782,8 @@ void SerializerVisitor::VisitPermuteLayer(const armnn::IConnectableLayer* layer,
                                           const armnn::PermuteDescriptor& permuteDescriptor,
                                           const char* name)
 {
+    boost::ignore_unused(name);
+
     // Create FlatBuffer BaseLayer
     auto flatBufferPermuteBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Permute);
 
@@ -746,6 +810,8 @@ void SerializerVisitor::VisitReshapeLayer(const armnn::IConnectableLayer* layer,
                                           const armnn::ReshapeDescriptor& reshapeDescriptor,
                                           const char* name)
 {
+    boost::ignore_unused(name);
+
     // Create FlatBuffer BaseLayer
     auto flatBufferReshapeBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Reshape);
 
@@ -770,6 +836,8 @@ void SerializerVisitor::VisitResizeBilinearLayer(const armnn::IConnectableLayer*
                                                  const armnn::ResizeBilinearDescriptor& resizeDescriptor,
                                                  const char* name)
 {
+    boost::ignore_unused(name);
+
     auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_ResizeBilinear);
 
     auto flatBufferDescriptor =
@@ -789,6 +857,8 @@ void SerializerVisitor::VisitResizeLayer(const armnn::IConnectableLayer* layer,
                                          const armnn::ResizeDescriptor& resizeDescriptor,
                                          const char* name)
 {
+    boost::ignore_unused(name);
+
     auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Resize);
 
     auto flatBufferDescriptor =
@@ -807,6 +877,8 @@ void SerializerVisitor::VisitResizeLayer(const armnn::IConnectableLayer* layer,
 
 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);
 
@@ -817,6 +889,8 @@ void SerializerVisitor::VisitSliceLayer(const armnn::IConnectableLayer* layer,
                                         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),
@@ -832,6 +906,8 @@ void SerializerVisitor::VisitSoftmaxLayer(const armnn::IConnectableLayer* layer,
                                           const armnn::SoftmaxDescriptor& softmaxDescriptor,
                                           const char* name)
 {
+    boost::ignore_unused(name);
+
     // Create FlatBuffer BaseLayer
     auto flatBufferSoftmaxBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Softmax);
 
@@ -852,6 +928,8 @@ void SerializerVisitor::VisitPooling2dLayer(const armnn::IConnectableLayer* laye
                                             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,
@@ -878,6 +956,8 @@ void SerializerVisitor::VisitPooling2dLayer(const armnn::IConnectableLayer* laye
 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);
 
@@ -890,6 +970,8 @@ void SerializerVisitor::VisitPreluLayer(const armnn::IConnectableLayer* layer,
 
 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);
@@ -903,6 +985,8 @@ void SerializerVisitor::VisitFullyConnectedLayer(const armnn::IConnectableLayer*
                                                  const armnn::Optional<armnn::ConstTensor>& biases,
                                                  const char* name)
 {
+    boost::ignore_unused(name);
+
     // Create FlatBuffer BaseLayer
     auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_FullyConnected);
 
@@ -938,6 +1022,8 @@ void SerializerVisitor::VisitSpaceToBatchNdLayer(const armnn::IConnectableLayer*
                                                  const armnn::SpaceToBatchNdDescriptor& spaceToBatchNdDescriptor,
                                                  const char* name)
 {
+    boost::ignore_unused(name);
+
     // Create FlatBuffer BaseLayer
     auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_SpaceToBatchNd);
 
@@ -967,6 +1053,8 @@ void SerializerVisitor::VisitSpaceToDepthLayer(const armnn::IConnectableLayer* l
                                                const armnn::SpaceToDepthDescriptor& spaceToDepthDescriptor,
                                                const char* name)
 {
+    boost::ignore_unused(name);
+
     auto flatBufferBaseLayer  = CreateLayerBase(layer, serializer::LayerType::LayerType_SpaceToDepth);
     auto flatBufferDescriptor =
         CreateSpaceToDepthDescriptor(m_flatBufferBuilder,
@@ -985,6 +1073,8 @@ void SerializerVisitor::VisitSplitterLayer(const armnn::IConnectableLayer* layer
                                            const armnn::ViewsDescriptor& viewsDescriptor,
                                            const char* name)
 {
+    boost::ignore_unused(name);
+
     // Create FlatBuffer ViewOrigins
     std::vector<flatbuffers::Offset<UintVector>> flatBufferViewOrigins;
     flatBufferViewOrigins.reserve(viewsDescriptor.GetNumViews());
@@ -1049,6 +1139,8 @@ void SerializerVisitor::VisitNormalizationLayer(const armnn::IConnectableLayer*
                                                 const armnn::NormalizationDescriptor& descriptor,
                                                 const char* name)
 {
+    boost::ignore_unused(name);
+
     auto fbNormalizationBaseLayer  = CreateLayerBase(layer, serializer::LayerType::LayerType_Normalization);
 
     auto fbNormalizationDescriptor = serializer::CreateNormalizationDescriptor(
@@ -1072,6 +1164,8 @@ void SerializerVisitor::VisitStackLayer(const armnn::IConnectableLayer* layer,
                                         const armnn::StackDescriptor& stackDescriptor,
                                         const char* name)
 {
+    boost::ignore_unused(name);
+
     auto stackBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_Stack);
 
     std::vector<unsigned int> inputShape;
@@ -1093,6 +1187,8 @@ void SerializerVisitor::VisitStandInLayer(const armnn::IConnectableLayer *layer,
                                           const armnn::StandInDescriptor& standInDescriptor,
                                           const char *name)
 {
+    boost::ignore_unused(name);
+
     auto fbDescriptor = serializer::CreateStandInDescriptor(m_flatBufferBuilder,
                                                             standInDescriptor.m_NumInputs,
                                                             standInDescriptor.m_NumOutputs);
@@ -1107,6 +1203,8 @@ void SerializerVisitor::VisitStridedSliceLayer(const armnn::IConnectableLayer* l
                                                const armnn::StridedSliceDescriptor& stridedSliceDescriptor,
                                                const char* name)
 {
+    boost::ignore_unused(name);
+
     auto flatBufferBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_StridedSlice);
 
     auto flatBufferDescriptor =
@@ -1130,6 +1228,8 @@ void SerializerVisitor::VisitStridedSliceLayer(const armnn::IConnectableLayer* l
 
 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);
 
@@ -1138,6 +1238,8 @@ void SerializerVisitor::VisitSubtractionLayer(const armnn::IConnectableLayer* la
 
 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);
 
@@ -1151,6 +1253,8 @@ void SerializerVisitor::VisitTransposeConvolution2dLayer(
     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,
@@ -1183,6 +1287,8 @@ void SerializerVisitor::VisitQuantizedLstmLayer(const armnn::IConnectableLayer*
                                                 const armnn::QuantizedLstmInputParams& params,
                                                 const char* name)
 {
+    boost::ignore_unused(name);
+
     auto fbQuantizedLstmBaseLayer = CreateLayerBase(layer, serializer::LayerType::LayerType_QuantizedLstm);
 
     // Get input parameters
@@ -1227,6 +1333,7 @@ void SerializerVisitor::VisitQuantizedLstmLayer(const armnn::IConnectableLayer*
 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);
@@ -1242,6 +1349,7 @@ fb::Offset<serializer::LayerBase> SerializerVisitor::CreateLayerBase(const IConn
 
 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);
 }