ArmNN
 21.02
Pooling2dTestImpl.cpp
Go to the documentation of this file.
1 //
2 // Copyright © 2017 Arm Ltd and Contributors. All rights reserved.
3 // SPDX-License-Identifier: MIT
4 //
5 
6 #include "Pooling2dTestImpl.hpp"
7 
8 #include <QuantizeHelper.hpp>
9 #include <ResolveType.hpp>
10 
11 #include <armnn/LayerSupport.hpp>
12 
13 #include <armnnUtils/TensorUtils.hpp>
14 #include <armnnUtils/DataLayoutIndexed.hpp>
15 #include <armnnUtils/Permute.hpp>
16 
17 #include <armnn/utility/IgnoreUnused.hpp>
18 #include <armnn/utility/NumericCast.hpp>
19 
20 #include <backendsCommon/WorkloadInfo.hpp>
21 
22 #include <backendsCommon/test/TensorCopyUtils.hpp>
23 #include <backendsCommon/test/WorkloadTestUtils.hpp>
24 
25 #include <test/TensorHelpers.hpp>
26 
27 namespace
28 {
29 
30 using namespace armnnUtils;
31 
32 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
33 LayerTestResult<T, 4> SimplePooling2dTestImpl(
34  armnn::IWorkloadFactory& workloadFactory,
35  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
36  const armnn::ITensorHandleFactory& tensorHandleFactory,
37  armnn::Pooling2dDescriptor descriptor,
38  float qScale,
39  int32_t qOffset,
40  const boost::multi_array<T, 4>& input,
41  const boost::multi_array<T, 4>& outputExpected)
42 {
43  IgnoreUnused(memoryManager);
44  const armnn::DataLayout dataLayout = descriptor.m_DataLayout;
45  const armnnUtils::DataLayoutIndexed dimensionIndices = dataLayout;
46  auto heightIndex = dimensionIndices.GetHeightIndex();
47  auto widthIndex = dimensionIndices.GetWidthIndex();
48  auto channelsIndex = dimensionIndices.GetChannelsIndex();
49 
50  unsigned int inputHeight = armnn::numeric_cast<unsigned int>(input.shape()[heightIndex]);
51  unsigned int inputWidth = armnn::numeric_cast<unsigned int>(input.shape()[widthIndex]);
52  unsigned int inputChannels = armnn::numeric_cast<unsigned int>(input.shape()[channelsIndex]);
53  unsigned int inputBatchSize = armnn::numeric_cast<unsigned int>(input.shape()[0]);
54 
55  unsigned int outputHeight = armnn::numeric_cast<unsigned int>(outputExpected.shape()[heightIndex]);
56  unsigned int outputWidth = armnn::numeric_cast<unsigned int>(outputExpected.shape()[widthIndex]);
57  unsigned int outputChannels = armnn::numeric_cast<unsigned int>(outputExpected.shape()[channelsIndex]);
58  unsigned int outputBatchSize = armnn::numeric_cast<unsigned int>(outputExpected.shape()[0]);
59 
60  armnn::TensorInfo inputTensorInfo = armnnUtils::GetTensorInfo(
61  inputBatchSize, inputChannels, inputHeight, inputWidth, dataLayout, ArmnnType);
62 
63  armnn::TensorInfo outputTensorInfo = armnnUtils::GetTensorInfo(
64  outputBatchSize, outputChannels, outputHeight, outputWidth, dataLayout, ArmnnType);
65 
66  // Set quantization parameters if the requested type is a quantized type.
67  if(armnn::IsQuantizedType<T>())
68  {
69  inputTensorInfo.SetQuantizationScale(qScale);
70  inputTensorInfo.SetQuantizationOffset(qOffset);
71  outputTensorInfo.SetQuantizationScale(qScale);
72  outputTensorInfo.SetQuantizationOffset(qOffset);
73  }
74 
75  LayerTestResult<T, 4> result(outputTensorInfo);
76 
77  std::unique_ptr<armnn::ITensorHandle> inputHandle = tensorHandleFactory.CreateTensorHandle(inputTensorInfo);
78  std::unique_ptr<armnn::ITensorHandle> outputHandle = tensorHandleFactory.CreateTensorHandle(outputTensorInfo);
79 
80  armnn::Pooling2dQueueDescriptor queueDescriptor;
81  queueDescriptor.m_Parameters = descriptor;
82  queueDescriptor.m_Parameters.m_DataLayout = dataLayout;
83 
84  armnn::WorkloadInfo workloadInfo;
85  AddInputToWorkload(queueDescriptor, workloadInfo, inputTensorInfo, inputHandle.get());
86  AddOutputToWorkload(queueDescriptor, workloadInfo, outputTensorInfo, outputHandle.get());
87 
88  // Don't execute if Pooling is not supported, as an exception will be raised.
89  armnn::BackendId backend = workloadFactory.GetBackendId();
90  const size_t reasonIfUnsupportedMaxLen = 255;
91  char reasonIfUnsupported[reasonIfUnsupportedMaxLen+1];
92  result.supported = armnn::IsPooling2dSupported(backend, inputTensorInfo, outputTensorInfo,
93  queueDescriptor.m_Parameters,
94  reasonIfUnsupported, reasonIfUnsupportedMaxLen);
95  if (!result.supported)
96  {
97  return result;
98  }
99 
100  std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreatePooling2d(queueDescriptor, workloadInfo);
101 
102  inputHandle->Allocate();
103  outputHandle->Allocate();
104 
105  CopyDataToITensorHandle(inputHandle.get(), &input[0][0][0][0]);
106 
107  workload->Execute();
108 
109  CopyDataFromITensorHandle(&result.output[0][0][0][0], outputHandle.get());
110 
111  result.outputExpected = outputExpected;
112 
113  return result;
114 }
115 
116 //
117 // Tests max pooling with the following parameters:
118 //
119 // Pooling size: 3x3
120 // Stride: (2,4)
121 // input size: 8x13
122 // channels: 2
123 // batch size: 2
124 //
125 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
126 LayerTestResult<T, 4> SimpleMaxPooling2dSize3x3Stride2x4TestCommon(
127  armnn::IWorkloadFactory& workloadFactory,
128  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
129  const armnn::ITensorHandleFactory& tensorHandleFactory,
130  bool forceNoPadding,
131  float qScale = 1.0f,
132  int32_t qOffset = 0)
133 {
134  armnn::Pooling2dDescriptor descriptor;
135  descriptor.m_PoolType = armnn::PoolingAlgorithm::Max;
136  descriptor.m_PoolWidth = descriptor.m_PoolHeight = 3;
137  descriptor.m_StrideX = 2;
138  descriptor.m_StrideY = 4;
139  // forceNoPadding is mainly used for compatibility with ARM Compute.
140  // As of 16/05/2017, it errors if padX or padY are equal to or greater than the pool size.
141  descriptor.m_PadLeft = descriptor.m_PadRight = forceNoPadding ? 0 : 3;
142  descriptor.m_PadTop = descriptor.m_PadBottom = 0;
143  descriptor.m_OutputShapeRounding = armnn::OutputShapeRounding::Floor;
144  descriptor.m_PaddingMethod = armnn::PaddingMethod::Exclude;
145 
146  unsigned int inputWidth = 8;
147  unsigned int inputHeight = 13;
148  unsigned int outputWidth =
149  (inputWidth + descriptor.m_PadLeft + descriptor.m_PadRight + descriptor.m_StrideX - descriptor.m_PoolWidth) /
150  descriptor.m_StrideX;
151  unsigned int outputHeight =
152  (inputHeight + descriptor.m_PadTop + descriptor.m_PadBottom + descriptor.m_StrideY - descriptor.m_PoolHeight) /
153  descriptor.m_StrideY;
154  unsigned int channels = 2;
155  unsigned int batchSize = 2;
156 
157  armnn::TensorInfo inputTensorInfo({ batchSize, channels, inputHeight, inputWidth }, ArmnnType);
158  armnn::TensorInfo outputTensorInfo({ batchSize, channels, outputHeight, outputWidth }, ArmnnType);
159 
160  // Set quantization parameters if the requested type is a quantized type.
161  if(armnn::IsQuantizedType<T>())
162  {
163  inputTensorInfo.SetQuantizationScale(qScale);
164  inputTensorInfo.SetQuantizationOffset(qOffset);
165  outputTensorInfo.SetQuantizationScale(qScale);
166  outputTensorInfo.SetQuantizationOffset(qOffset);
167  }
168 
169  std::vector<float> singleChannelData({
170  0.0f, 4.0f, 8.0f, 1.0f, 6.0f, 4.0f, 5.0f, 8.0f,
171  1.0f, 1.0f, 6.0f, 0.0f, 3.0f, 7.0f, 4.0f, 7.0f,
172  8.0f, 5.0f, 0.0f, 0.0f, 8.0f, 3.0f, 4.0f, 3.0f,
173  8.0f, 2.0f, 5.0f, 4.0f, 1.0f, 9.0f, 2.0f, 0.0f,
174  5.0f, 4.0f, 5.0f, 0.0f, 0.0f, 0.0f, 7.0f, 2.0f,
175  1.0f, 2.0f, 6.0f, 2.0f, 7.0f, 9.0f, 5.0f, 2.0f,
176  9.0f, 7.0f, 3.0f, 1.0f, 3.0f, 4.0f, 8.0f, 3.0f,
177  1.0f, 0.0f, 0.0f, 5.0f, 5.0f, 4.0f, 2.0f, 0.0f,
178  6.0f, 4.0f, 3.0f, 6.0f, 9.0f, 5.0f, 5.0f, 6.0f,
179  8.0f, 7.0f, 9.0f, 6.0f, 1.0f, 4.0f, 1.0f, 9.0f,
180  7.0f, 1.0f, 9.0f, 2.0f, 9.0f, 9.0f, 8.0f, 1.0f,
181  4.0f, 4.0f, 5.0f, 9.0f, 2.0f, 6.0f, 6.0f, 4.0f,
182  3.0f, 5.0f, 4.0f, 0.0f, 1.0f, 5.0f, 9.0f, 7.0f,
183  });
184 
185  // Constructs input data.
186  std::vector<float> inputData;
187  auto negator = [](float f) { return -f; };
188 
189  // First image (two channels where the second channel is the negative of the first one).
190  inputData.insert(inputData.end(), singleChannelData.begin(), singleChannelData.end());
191  std::transform(singleChannelData.begin(), singleChannelData.end(), std::back_inserter(inputData), negator);
192 
193  // Second image (same as first image).
194  inputData.insert(inputData.end(), singleChannelData.begin(), singleChannelData.end());
195  std::transform(singleChannelData.begin(), singleChannelData.end(), std::back_inserter(inputData), negator);
196 
197  auto input = MakeTensor<T, 4>(inputTensorInfo, QuantizedVector<T>(inputData, qScale, qOffset));
198 
199  // These were calculated manually.
200  auto shape(GetTensorShapeAsArray<4>(outputTensorInfo));
201  boost::multi_array<T, 4> outputExpected(shape);
202  if (forceNoPadding)
203  {
204  outputExpected = MakeTensor<T, 4>(outputTensorInfo,
205  QuantizedVector<T>({
206  8.0f, 8.0f, 8.0f,
207  9.0f, 7.0f, 9.0f,
208  9.0f, 9.0f, 9.0f,
209 
210  0.0f, 0.0f, -3.0f,
211  -1.0f, 0.0f, 0.0f,
212  -1.0f, -1.0f, -1.0f,
213 
214  8.0f, 8.0f, 8.0f,
215  9.0f, 7.0f, 9.0f,
216  9.0f, 9.0f, 9.0f,
217 
218  0.0f, 0.0f, -3.0f,
219  -1.0f, 0.0f, 0.0f,
220  -1.0f, -1.0f, -1.0f
221  },
222  qScale, qOffset));
223  }
224  else
225  {
226  outputExpected = MakeTensor<T, 4>(outputTensorInfo,
227  QuantizedVector<T>({
228  0.0f, 8.0f, 8.0f, 8.0f, 8.0f, 8.0f,
229  0.0f, 9.0f, 7.0f, 9.0f, 9.0f, 3.0f,
230  0.0f, 8.0f, 9.0f, 9.0f, 9.0f, 9.0f,
231 
232  0.0f, 0.0f, 0.0f, 0.0f,-3.0f,-3.0f,
233  0.0f,-1.0f, 0.0f, 0.0f, 0.0f,-2.0f,
234  0.0f,-1.0f,-1.0f,-1.0f,-1.0f,-1.0f,
235 
236  0.0f, 8.0f, 8.0f, 8.0f, 8.0f, 8.0f,
237  0.0f, 9.0f, 7.0f, 9.0f, 9.0f, 3.0f,
238  0.0f, 8.0f, 9.0f, 9.0f, 9.0f, 9.0f,
239 
240  0.0f, 0.0f, 0.0f, 0.0f,-3.0f,-3.0f,
241  0.0f,-1.0f, 0.0f, 0.0f, 0.0f,-2.0f,
242  0.0f,-1.0f,-1.0f,-1.0f,-1.0f,-1.0f
243  },
244  qScale, qOffset));
245  }
246 
247  return SimplePooling2dTestImpl<ArmnnType>(
248  workloadFactory, memoryManager, tensorHandleFactory, descriptor, qScale, qOffset, input, outputExpected);
249 }
250 
251 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
252 LayerTestResult<T, 4> SimpleMaxPooling2dTestCommon(
253  armnn::IWorkloadFactory& workloadFactory,
254  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
255  const armnn::ITensorHandleFactory& tensorHandleFactory,
256  const armnn::DataLayout dataLayout = armnn::DataLayout::NCHW,
257  float qScale = 1.0f,
258  int32_t qOffset = 0)
259 {
260  armnn::Pooling2dDescriptor descriptor;
261  descriptor.m_PoolType = armnn::PoolingAlgorithm::Max;
262  descriptor.m_PoolWidth = descriptor.m_PoolHeight = 2;
263  descriptor.m_StrideX = descriptor.m_StrideY = 2;
264  descriptor.m_PaddingMethod = armnn::PaddingMethod::Exclude;
265  descriptor.m_DataLayout = dataLayout;
266 
267  armnn::TensorInfo inputTensorInfo = armnnUtils::GetTensorInfo(1, 2, 4, 4, dataLayout, ArmnnType);
268  armnn::TensorInfo outputTensorInfo = armnnUtils::GetTensorInfo(1, 2, 2, 2, dataLayout, ArmnnType);
269 
270  // Set quantization parameters if the requested type is a quantized type.
271  if(armnn::IsQuantizedType<T>())
272  {
273  inputTensorInfo.SetQuantizationScale(qScale);
274  inputTensorInfo.SetQuantizationOffset(qOffset);
275  outputTensorInfo.SetQuantizationScale(qScale);
276  outputTensorInfo.SetQuantizationOffset(qOffset);
277  }
278 
279  std::vector<T> inputData(
280  QuantizedVector<T>({
281  1.0f, 2.0f, 5.0f, 6.0f,
282  3.0f, 4.0f, 7.0f, 8.0f,
283  9.0f, 10.0f, 13.0f, 14.0f,
284  11.0f, 12.0f, 15.0f, 16.0f,
285 
286  17.0f, 18.0f, 21.0f, 22.0f,
287  19.0f, 20.0f, 23.0f, 24.0f,
288  25.0f, 26.0f, 29.0f, 30.0f,
289  27.0f, 28.0f, 31.0f, 32.0f,
290  },
291  qScale, qOffset));
292 
293  std::vector<T> outputData(
294  QuantizedVector<T>({
295  4.0f, 8.0f,
296  12.0f, 16.0f,
297 
298  20.0f, 24.0f,
299  28.0f, 32.0f,
300  },
301  qScale, qOffset));
302 
303  const armnn::PermutationVector NCHWToNHWC = { 0, 3, 1, 2 };
304  if (dataLayout == armnn::DataLayout::NHWC)
305  {
306  std::vector<T> tmp(inputData.size());
307  armnnUtils::Permute(inputTensorInfo.GetShape(), NCHWToNHWC, inputData.data(), tmp.data(), sizeof(T));
308  inputData = tmp;
309 
310  std::vector<T> tmp1(outputData.size());
311  armnnUtils::Permute(outputTensorInfo.GetShape(), NCHWToNHWC, outputData.data(), tmp1.data(), sizeof(T));
312  outputData = tmp1;
313  }
314 
315  auto input = MakeTensor<T, 4>(inputTensorInfo, inputData);
316 
317  auto outputExpected = MakeTensor<T, 4>(outputTensorInfo, outputData);
318 
319  return SimplePooling2dTestImpl<ArmnnType>(
320  workloadFactory, memoryManager, tensorHandleFactory, descriptor, qScale, qOffset, input, outputExpected);
321 }
322 
323 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
324 LayerTestResult<T, 4> SimpleAveragePooling2dTestCommon(
325  armnn::IWorkloadFactory& workloadFactory,
326  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
327  const armnn::ITensorHandleFactory& tensorHandleFactory,
328  armnn::DataLayout dataLayout = armnn::DataLayout::NCHW,
329  float qScale = 1.0f,
330  int32_t qOffset = 0)
331 {
332  armnn::Pooling2dDescriptor descriptor;
333  descriptor.m_PoolType = armnn::PoolingAlgorithm::Average;
334  descriptor.m_PoolWidth = descriptor.m_PoolHeight = 2;
335  descriptor.m_StrideX = descriptor.m_StrideY = 2;
336  descriptor.m_PaddingMethod = armnn::PaddingMethod::Exclude;
337  descriptor.m_DataLayout = dataLayout;
338 
339  armnn::TensorInfo inputTensorInfo = armnnUtils::GetTensorInfo(1, 2, 4, 4, dataLayout, ArmnnType);
340  armnn::TensorInfo outputTensorInfo = armnnUtils::GetTensorInfo(1, 2, 2, 2, dataLayout, ArmnnType);
341 
342  // Set quantization parameters if the requested type is a quantized type.
343  if(armnn::IsQuantizedType<T>())
344  {
345  inputTensorInfo.SetQuantizationScale(qScale);
346  inputTensorInfo.SetQuantizationOffset(qOffset);
347  outputTensorInfo.SetQuantizationScale(qScale);
348  outputTensorInfo.SetQuantizationOffset(qOffset);
349  }
350 
351  std::vector<T> inputData(
352  QuantizedVector<T>({
353  2.0f, 2.0f, 6.0f, 6.0f,
354  4.0f, 4.0f, 8.0f, 8.0f,
355  10.0f, 12.0f, 14.0f, 16.0f,
356  10.0f, 12.0f, 16.0f, 14.0f,
357 
358  18.0f, 20.0f, 24.0f, 22.0f,
359  20.0f, 18.0f, 22.0f, 24.0f,
360  26.0f, 28.0f, 0.0f, 0.0f,
361  26.0f, 28.0f, 0.0f, 0.0f,
362  },
363  qScale, qOffset));
364 
365  std::vector<T> outputData(
366  QuantizedVector<T>({
367  3.0f, 7.0f,
368  11.0f, 15.0f,
369 
370  19.0f, 23.0f,
371  27.0f, 0.0f,
372  },
373  qScale, qOffset));
374 
375  const armnn::PermutationVector NCHWToNHWC = { 0, 3, 1, 2 };
376  if (dataLayout == armnn::DataLayout::NHWC)
377  {
378  std::vector<T> tmp(inputData.size());
379  armnnUtils::Permute(inputTensorInfo.GetShape(), NCHWToNHWC, inputData.data(), tmp.data(), sizeof(T));
380  inputData = tmp;
381 
382  std::vector<T> tmp1(outputData.size());
383  armnnUtils::Permute(outputTensorInfo.GetShape(), NCHWToNHWC, outputData.data(), tmp1.data(), sizeof(T));
384  outputData = tmp1;
385  }
386 
387  auto input = MakeTensor<T, 4>(inputTensorInfo, inputData);
388 
389  auto outputExpected = MakeTensor<T, 4>(outputTensorInfo, outputData);
390 
391  return SimplePooling2dTestImpl<ArmnnType>(
392  workloadFactory, memoryManager, tensorHandleFactory, descriptor, qScale, qOffset, input, outputExpected);
393 }
394 
395 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
396 LayerTestResult<T, 4> LargeTensorsAveragePooling2dTestCommon(
397  armnn::IWorkloadFactory& workloadFactory,
398  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
399  const armnn::ITensorHandleFactory& tensorHandleFactory,
400  float qScale = 1.0f,
401  int32_t qOffset = 0)
402 {
403  armnn::Pooling2dDescriptor descriptor;
404  descriptor.m_PoolType = armnn::PoolingAlgorithm::Average;
405  descriptor.m_PoolWidth = descriptor.m_PoolHeight = 100;
406  descriptor.m_StrideX = descriptor.m_StrideY = 5;
407  descriptor.m_PadLeft = 50;
408  descriptor.m_PadRight = 50;
409  descriptor.m_PadTop = 50;
410  descriptor.m_PadBottom = 50;
411  descriptor.m_PaddingMethod = armnn::PaddingMethod::Exclude;
412 
413  armnn::TensorInfo inputTensorInfo({ 5, 3, 52, 60 }, ArmnnType);
414  armnn::TensorInfo outputTensorInfo({ 5, 3, 11, 13 }, ArmnnType);
415 
416  // Set quantization parameters if the requested type is a quantized type.
417  if(armnn::IsQuantizedType<T>())
418  {
419  inputTensorInfo.SetQuantizationScale(qScale);
420  inputTensorInfo.SetQuantizationOffset(qOffset);
421  outputTensorInfo.SetQuantizationScale(qScale);
422  outputTensorInfo.SetQuantizationOffset(qOffset);
423  }
424 
425  std::vector<T> inputVec;
426 
427  for (unsigned int i = 0 ; i < inputTensorInfo.GetShape().GetNumElements(); ++i)
428  {
429  inputVec.push_back(1);
430  }
431 
432  auto input = MakeTensor<T, 4>(inputTensorInfo, inputVec);
433 
434  std::vector<T> outputVec;
435 
436  for (unsigned int i = 0 ; i < outputTensorInfo.GetShape().GetNumElements(); ++i)
437  {
438  outputVec.push_back(1);
439  }
440 
441  auto outputExpected = MakeTensor<T, 4>(outputTensorInfo, outputVec);
442 
443  return SimplePooling2dTestImpl<ArmnnType>(
444  workloadFactory, memoryManager, tensorHandleFactory, descriptor, qScale, qOffset, input, outputExpected);
445 }
446 
447 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
448 LayerTestResult<T, 4> SimpleL2Pooling2dTestCommon(
449  armnn::IWorkloadFactory& workloadFactory,
450  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
451  const armnn::ITensorHandleFactory& tensorHandleFactory,
452  armnn::DataLayout dataLayout = armnn::DataLayout::NCHW,
453  float qScale = 1.0f,
454  int32_t qOffset = 0)
455 {
456  armnn::Pooling2dDescriptor descriptor;
457  descriptor.m_PoolType = armnn::PoolingAlgorithm::L2;
458  descriptor.m_PoolWidth = descriptor.m_PoolHeight = 2;
459  descriptor.m_StrideX = descriptor.m_StrideY = 2;
460  descriptor.m_PaddingMethod = armnn::PaddingMethod::Exclude;
461  descriptor.m_DataLayout = dataLayout;
462 
463  armnn::TensorInfo inputTensorInfo = armnnUtils::GetTensorInfo(1, 2, 4, 4, dataLayout, ArmnnType);
464  armnn::TensorInfo outputTensorInfo = armnnUtils::GetTensorInfo(1, 2, 2, 2, dataLayout, ArmnnType);
465 
466  std::vector<T> inputData(
467  QuantizedVector<T>({
468  1.0f, 7.0f, 5.0f, 5.0f,
469  1.0f, 7.0f, 5.0f, 5.0f,
470  3.0f, 3.0f, 1.0f, 1.0f,
471  3.0f, 3.0f, 1.0f, 1.0f,
472 
473  1.0f, 7.0f, 0.0f, 0.0f,
474  1.0f, 7.0f, 2.0f, 0.0f,
475  0.0f, 2.0f, 1.0f, 1.0f,
476  0.0f, 0.0f, 1.0f, 1.0f,
477  },
478  qScale, qOffset));
479 
480  std::vector<T> outputData(
481  QuantizedVector<T>({
482  5.0f, 5.0f,
483  3.0f, 1.0f,
484 
485  5.0f, 1.0f,
486  1.0f, 1.0f,
487  },
488  qScale, qOffset));
489 
490  const armnn::PermutationVector NCHWToNHWC = { 0, 3, 1, 2 };
491  if (dataLayout == armnn::DataLayout::NHWC)
492  {
493  std::vector<T> tmp(inputData.size());
494  armnnUtils::Permute(inputTensorInfo.GetShape(), NCHWToNHWC, inputData.data(), tmp.data(), sizeof(T));
495  inputData = tmp;
496 
497  std::vector<T> tmp1(outputData.size());
498  armnnUtils::Permute(outputTensorInfo.GetShape(), NCHWToNHWC, outputData.data(), tmp1.data(), sizeof(T));
499  outputData = tmp1;
500  }
501 
502  auto input = MakeTensor<T, 4>(inputTensorInfo, inputData);
503 
504  auto outputExpected = MakeTensor<T, 4>(outputTensorInfo, outputData);
505 
506  return SimplePooling2dTestImpl<ArmnnType>(
507  workloadFactory, memoryManager, tensorHandleFactory, descriptor, qScale, qOffset, input, outputExpected);
508 }
509 
510 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
511 LayerTestResult<T, 4> L2Pooling2dSize3Stride1TestCommon(
512  armnn::IWorkloadFactory& workloadFactory,
513  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
514  const armnn::ITensorHandleFactory& tensorHandleFactory,
515  float qScale = 1.0f,
516  int32_t qOffset = 0)
517 {
518  armnn::Pooling2dDescriptor descriptor;
519  descriptor.m_PoolType = armnn::PoolingAlgorithm::L2;
520  descriptor.m_PoolWidth = descriptor.m_PoolHeight = 3;
521  descriptor.m_StrideX = descriptor.m_StrideY = 1;
522  descriptor.m_PaddingMethod = armnn::PaddingMethod::Exclude;
523 
524  armnn::TensorInfo inputTensorInfo({ 1, 1, 4, 4 }, ArmnnType);
525  auto input = MakeTensor<T, 4>(inputTensorInfo,
526  QuantizedVector<T>({
527  2.0f, 1.0f, 5.0f, 2.0f,
528  1.0f, 2.0f, 2.0f, 1.0f,
529  5.0f, 4.0f, 1.0f, 5.0f,
530  2.0f, 1.0f, 5.0f, 2.0f,
531  },
532  qScale, qOffset));
533 
534  armnn::TensorInfo outputTensorInfo({ 1, 1, 2, 2 }, ArmnnType);
535  auto outputExpected = MakeTensor<T, 4>(outputTensorInfo,
536  QuantizedVector<T>({
537  3.0f, 3.0f,
538  3.0f, 3.0f,
539  },
540  qScale, qOffset));
541 
542  return SimplePooling2dTestImpl<ArmnnType>(
543  workloadFactory, memoryManager, tensorHandleFactory, descriptor, qScale, qOffset, input, outputExpected);
544 }
545 
546 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
547 LayerTestResult<T, 4> L2Pooling2dSize3Stride3TestCommon(
548  armnn::IWorkloadFactory& workloadFactory,
549  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
550  const armnn::ITensorHandleFactory& tensorHandleFactory,
551  float qScale = 1.0f,
552  int32_t qOffset = 0)
553 {
554  armnn::Pooling2dDescriptor descriptor;
555  descriptor.m_PoolType = armnn::PoolingAlgorithm::L2;
556  descriptor.m_PoolWidth = descriptor.m_PoolHeight = 3;
557  descriptor.m_StrideX = descriptor.m_StrideY = 3;
558  descriptor.m_PaddingMethod = armnn::PaddingMethod::Exclude;
559 
560  armnn::TensorInfo inputTensorInfo({ 1, 1, 9, 9 }, ArmnnType);
561  auto input = MakeTensor<T, 4>(inputTensorInfo,
562  QuantizedVector<T>({
563  2.0f, 1.0f, 5.0f, 2.0f, 1.0f, 5.0f, 2.0f, 1.0f, 5.0f,
564  1.0f, 2.0f, 2.0f, 1.0f, 2.0f, 2.0f, 1.0f, 2.0f, 2.0f,
565  5.0f, 4.0f, 1.0f, 5.0f, 4.0f, 1.0f, 5.0f, 4.0f, 1.0f,
566  2.0f, 1.0f, 5.0f, 2.0f, 1.0f, 5.0f, 2.0f, 1.0f, 5.0f,
567  1.0f, 2.0f, 2.0f, 1.0f, 2.0f, 2.0f, 1.0f, 2.0f, 2.0f,
568  5.0f, 4.0f, 1.0f, 5.0f, 4.0f, 1.0f, 5.0f, 4.0f, 1.0f,
569  2.0f, 1.0f, 5.0f, 2.0f, 1.0f, 5.0f, 2.0f, 1.0f, 5.0f,
570  1.0f, 2.0f, 2.0f, 1.0f, 2.0f, 2.0f, 1.0f, 2.0f, 2.0f,
571  5.0f, 4.0f, 1.0f, 5.0f, 4.0f, 1.0f, 5.0f, 4.0f, 1.0f,
572  },
573  qScale, qOffset));
574 
575  armnn::TensorInfo outputTensorInfo({ 1, 1, 3, 3 }, ArmnnType);
576  auto outputExpected = MakeTensor<T, 4>(outputTensorInfo,
577  QuantizedVector<T>({
578  3.0f, 3.0f, 3.0f,
579  3.0f, 3.0f, 3.0f,
580  3.0f, 3.0f, 3.0f,
581  },
582  qScale, qOffset));
583 
584  return SimplePooling2dTestImpl<ArmnnType>(
585  workloadFactory, memoryManager, tensorHandleFactory, descriptor, qScale, qOffset, input, outputExpected);
586 }
587 
588 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
589 LayerTestResult<T, 4> L2Pooling2dSize3Stride4TestCommon(
590  armnn::IWorkloadFactory& workloadFactory,
591  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
592  const armnn::ITensorHandleFactory& tensorHandleFactory,
593  float qScale = 1.0f,
594  int32_t qOffset = 0)
595 {
596  armnn::Pooling2dDescriptor descriptor;
597  descriptor.m_PoolType = armnn::PoolingAlgorithm::L2;
598  descriptor.m_PoolWidth = descriptor.m_PoolHeight = 3;
599  descriptor.m_StrideX = descriptor.m_StrideY = 4;
600  descriptor.m_PaddingMethod = armnn::PaddingMethod::Exclude;
601 
602  armnn::TensorInfo inputTensorInfo({ 1, 1, 7, 7 }, ArmnnType);
603  auto input = MakeTensor<T, 4>(inputTensorInfo,
604  QuantizedVector<T>({
605  2.0f, 1.0f, 5.0f, 0.0f, 2.0f, 1.0f, 5.0f,
606  1.0f, 2.0f, 2.0f, 0.0f, 1.0f, 2.0f, 2.0f,
607  5.0f, 4.0f, 1.0f, 0.0f, 5.0f, 4.0f, 1.0f,
608  0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
609  2.0f, 1.0f, 5.0f, 0.0f, 2.0f, 1.0f, 5.0f,
610  1.0f, 2.0f, 2.0f, 0.0f, 1.0f, 2.0f, 2.0f,
611  5.0f, 4.0f, 1.0f, 0.0f, 5.0f, 4.0f, 1.0f,
612  },
613  qScale, qOffset));
614 
615  armnn::TensorInfo outputTensorInfo({ 1, 1, 2, 2 }, ArmnnType);
616  auto outputExpected = MakeTensor<T, 4>(outputTensorInfo,
617  QuantizedVector<T>({
618  3.0f, 3.0f,
619  3.0f, 3.0f,
620  },
621  qScale, qOffset));
622 
623  return SimplePooling2dTestImpl<ArmnnType>(
624  workloadFactory, memoryManager, tensorHandleFactory, descriptor, qScale, qOffset, input, outputExpected);
625 }
626 
627 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
628 LayerTestResult<T, 4> L2Pooling2dSize7TestCommon(
629  armnn::IWorkloadFactory& workloadFactory,
630  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
631  const armnn::ITensorHandleFactory& tensorHandleFactory,
632  float qScale = 1.0f,
633  int32_t qOffset = 0)
634 {
635  armnn::Pooling2dDescriptor descriptor;
636  descriptor.m_PoolType = armnn::PoolingAlgorithm::L2;
637  descriptor.m_PoolWidth = descriptor.m_PoolHeight = 7;
638  descriptor.m_StrideX = descriptor.m_StrideY = 7;
639  descriptor.m_PaddingMethod = armnn::PaddingMethod::Exclude;
640 
641  armnn::TensorInfo inputTensorInfo({ 1, 1, 7, 7 }, ArmnnType);
642  auto input = MakeTensor<T, 4>(inputTensorInfo,
643  QuantizedVector<T>({
644  1.0f, 0.0f, 2.0f, 0.0f, 3.0f, 0.0f, 4.0f,
645  0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
646  0.0f, 5.0f, 0.0f, 6.0f, 0.0f, 7.0f, 0.0f,
647  8.0f, 0.0f, 9.0f, 0.0f, 10.0f, 0.0f, 5.0f,
648  0.0f, 5.0f, 0.0f, 2.0f, 0.0f, 1.0f, 1.0f,
649  0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
650  0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
651  },
652  qScale, qOffset));
653 
654  armnn::TensorInfo outputTensorInfo({ 1, 1, 1, 1 }, ArmnnType);
655  auto outputExpected = MakeTensor<T, 4>(outputTensorInfo,
656  QuantizedVector<T>({
657  3.0f,
658  },
659  qScale, qOffset));
660 
661  return SimplePooling2dTestImpl<ArmnnType>(
662  workloadFactory, memoryManager, tensorHandleFactory, descriptor, qScale, qOffset, input, outputExpected);
663 }
664 
665 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
666 LayerTestResult<T, 4> L2Pooling2dSize9TestCommon(
667  armnn::IWorkloadFactory& workloadFactory,
668  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
669  const armnn::ITensorHandleFactory& tensorHandleFactory,
670  float qScale = 1.0f,
671  int32_t qOffset = 0)
672 {
673  armnn::Pooling2dDescriptor descriptor;
674  descriptor.m_PoolType = armnn::PoolingAlgorithm::L2;
675  descriptor.m_PoolWidth = descriptor.m_PoolHeight = 9;
676  descriptor.m_StrideX = descriptor.m_StrideY = 9;
677  descriptor.m_PaddingMethod = armnn::PaddingMethod::Exclude;
678 
679  armnn::TensorInfo inputTensorInfo({ 1, 1, 9, 9 }, ArmnnType);
680  auto input = MakeTensor<T, 4>(inputTensorInfo,
681  QuantizedVector<T>({
682  2.0f, 1.0f, 5.0f, 2.0f, 1.0f, 5.0f, 2.0f, 1.0f, 5.0f,
683  1.0f, 2.0f, 2.0f, 1.0f, 2.0f, 2.0f, 1.0f, 2.0f, 2.0f,
684  5.0f, 4.0f, 1.0f, 5.0f, 4.0f, 1.0f, 5.0f, 4.0f, 1.0f,
685  2.0f, 1.0f, 5.0f, 2.0f, 1.0f, 5.0f, 2.0f, 1.0f, 5.0f,
686  1.0f, 2.0f, 2.0f, 1.0f, 2.0f, 2.0f, 1.0f, 2.0f, 2.0f,
687  5.0f, 4.0f, 1.0f, 5.0f, 4.0f, 1.0f, 5.0f, 4.0f, 1.0f,
688  2.0f, 1.0f, 5.0f, 2.0f, 1.0f, 5.0f, 2.0f, 1.0f, 5.0f,
689  1.0f, 2.0f, 2.0f, 1.0f, 2.0f, 2.0f, 1.0f, 2.0f, 2.0f,
690  5.0f, 4.0f, 1.0f, 5.0f, 4.0f, 1.0f, 5.0f, 4.0f, 1.0f,
691  },
692  qScale, qOffset));
693 
694  armnn::TensorInfo outputTensorInfo({ 1, 1, 1, 1 }, ArmnnType);
695  auto outputExpected = MakeTensor<T, 4>(outputTensorInfo,
696  QuantizedVector<T>({
697  3.0f,
698  },
699  qScale, qOffset));
700 
701  return SimplePooling2dTestImpl<ArmnnType>(
702  workloadFactory, memoryManager, tensorHandleFactory, descriptor, qScale, qOffset, input, outputExpected);
703 }
704 
705 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
706 LayerTestResult<T, 4> AsymmetricNonSquarePooling2dTestCommon(
707  armnn::IWorkloadFactory& workloadFactory,
708  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
709  const armnn::ITensorHandleFactory& tensorHandleFactory,
710  float qScale = 1.0f,
711  int32_t qOffset = 0)
712 {
713  armnn::TensorInfo inputTensorInfo({ 1, 1, 1, 3 }, ArmnnType);
714  armnn::TensorInfo outputTensorInfo({ 1, 1, 2, 2 }, ArmnnType);
715 
716  armnn::Pooling2dDescriptor descriptor;
717  descriptor.m_PoolType = armnn::PoolingAlgorithm::Max;
718  descriptor.m_PoolWidth = 2;
719  descriptor.m_PoolHeight = 3;
720  descriptor.m_StrideX = 2;
721  descriptor.m_StrideY = 1;
722  descriptor.m_PadLeft = 2;
723  descriptor.m_PadRight = 0;
724  descriptor.m_PadTop = 1;
725  descriptor.m_PadBottom = 2;
726  descriptor.m_OutputShapeRounding = armnn::OutputShapeRounding::Floor;
727  descriptor.m_PaddingMethod = armnn::PaddingMethod::Exclude;
728 
729  // Construct input data.
730  auto input = MakeTensor<T, 4>(inputTensorInfo,
731  QuantizedVector<T>({
732  1.0f, 3.0f, 4.0f,
733  },
734  qScale, qOffset));
735 
736  // These were calculated manually.
737  auto outputExpected = MakeTensor<T, 4>(outputTensorInfo,
738  QuantizedVector<T>({
739  0.0f, 3.0f, 0.0f, 3.0f,
740  },
741  qScale, qOffset));
742 
743  return SimplePooling2dTestImpl<ArmnnType>(
744  workloadFactory, memoryManager, tensorHandleFactory, descriptor, qScale, qOffset, input, outputExpected);
745 }
746 
747 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
748 LayerTestResult<T, 4> ComparePooling2dTestCommon(
749  armnn::IWorkloadFactory& workloadFactory,
750  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
751  armnn::IWorkloadFactory& refWorkloadFactory,
752  const armnn::ITensorHandleFactory& tensorHandleFactory,
753  const armnn::ITensorHandleFactory& refTensorHandleFactory,
754  armnn::PoolingAlgorithm poolingType,
755  float qScale = 1.0f,
756  int32_t qOffset = 0)
757 {
758  IgnoreUnused(memoryManager);
759  const unsigned int inputWidth = 16;
760  const unsigned int inputHeight = 32;
761  const unsigned int channelCount = 2;
762  const unsigned int batchSize = 5;
763 
764  const unsigned int poolSize = 3;
765  const unsigned int strideX = 2;
766  const unsigned int strideY = 4;
767  const unsigned int padX = 0;
768  const unsigned int padY = 0;
769 
770  const unsigned int outputWidth = (inputWidth + 2 * padX + strideX - poolSize) / strideX;
771  const unsigned int outputHeight = (inputHeight + 2 * padY + strideY - poolSize) / strideY;
772 
773  armnn::TensorInfo inputTensorInfo;
774  armnn::TensorInfo outputTensorInfo;
775 
776  unsigned int inputShape[] = { batchSize, channelCount, inputHeight, inputWidth };
777  unsigned int outputShape[] = { batchSize, channelCount, outputHeight, outputWidth };
778 
779  inputTensorInfo = armnn::TensorInfo(4, inputShape, ArmnnType);
780  outputTensorInfo = armnn::TensorInfo(4, outputShape, ArmnnType);
781 
782  // Set quantization parameters if the requested type is a quantized type.
783  if(armnn::IsQuantizedType<T>())
784  {
785  inputTensorInfo.SetQuantizationScale(qScale);
786  inputTensorInfo.SetQuantizationOffset(qOffset);
787  outputTensorInfo.SetQuantizationScale(qScale);
788  outputTensorInfo.SetQuantizationOffset(qOffset);
789  }
790 
791  boost::multi_array<T, 4> input = MakeRandomTensor<T, 4>(inputTensorInfo, 81715);
792 
793  LayerTestResult<T, 4> comparisonResult(outputTensorInfo);
794 
795  std::unique_ptr<armnn::ITensorHandle> inputHandle = tensorHandleFactory.CreateTensorHandle(inputTensorInfo);
796  std::unique_ptr<armnn::ITensorHandle> outputHandle = tensorHandleFactory.CreateTensorHandle(outputTensorInfo);
797 
798  armnn::Pooling2dQueueDescriptor data;
799  armnn::WorkloadInfo info;
800  AddInputToWorkload(data, info, inputTensorInfo, inputHandle.get());
801  AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
802  data.m_Parameters.m_PoolType = poolingType;
803  data.m_Parameters.m_PoolWidth = poolSize;
804  data.m_Parameters.m_PoolHeight = poolSize;
805  data.m_Parameters.m_StrideX = strideX;
806  data.m_Parameters.m_StrideY = strideY;
807  data.m_Parameters.m_PadLeft = padX;
808  data.m_Parameters.m_PadRight = padX;
809  data.m_Parameters.m_PadTop = padY;
810  data.m_Parameters.m_PadBottom = padY;
811  data.m_Parameters.m_OutputShapeRounding = armnn::OutputShapeRounding::Floor;
812 
813  std::unique_ptr<armnn::ITensorHandle> outputHandleRef = refTensorHandleFactory.CreateTensorHandle(outputTensorInfo);
814  std::unique_ptr<armnn::ITensorHandle> inputHandleRef = refTensorHandleFactory.CreateTensorHandle(inputTensorInfo);
815 
816  // Don't execute if Pooling is not supported, as an exception will be raised.
817  armnn::BackendId backend = workloadFactory.GetBackendId();
818  const size_t reasonIfUnsupportedMaxLen = 255;
819  char reasonIfUnsupported[reasonIfUnsupportedMaxLen+1];
820  comparisonResult.supported = armnn::IsPooling2dSupported(backend, inputTensorInfo, outputTensorInfo,
821  data.m_Parameters,
822  reasonIfUnsupported, reasonIfUnsupportedMaxLen);
823  if (!comparisonResult.supported)
824  {
825  return comparisonResult;
826  }
827 
828  armnn::Pooling2dQueueDescriptor refData = data;
829  armnn::WorkloadInfo refInfo = info;
830  SetWorkloadInput(refData, refInfo, 0, inputTensorInfo, inputHandleRef.get());
831  SetWorkloadOutput(refData, refInfo, 0, outputTensorInfo, outputHandleRef.get());
832 
833  std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreatePooling2d(data, info);
834  std::unique_ptr<armnn::IWorkload> workloadRef = refWorkloadFactory.CreatePooling2d(refData, refInfo);
835 
836  outputHandleRef->Allocate();
837  inputHandleRef->Allocate();
838  inputHandle->Allocate();
839  outputHandle->Allocate();
840 
841  CopyDataToITensorHandle(inputHandle.get(), &input[0][0][0][0]);
842  CopyDataToITensorHandle(inputHandleRef.get(), &input[0][0][0][0]);
843 
844  workload->Execute();
845  workloadRef->Execute();
846 
847  CopyDataFromITensorHandle(&comparisonResult.output[0][0][0][0], outputHandle.get());
848  CopyDataFromITensorHandle(&comparisonResult.outputExpected[0][0][0][0], outputHandleRef.get());
849 
850  return comparisonResult;
851 }
852 
853 //
854 // Tests max pooling with the following parameters:
855 //
856 // Pooling size: 2x2
857 // Stride: (2,2)
858 // input size: 4x4
859 // channels: 1
860 // batch size: 1
861 //
862 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
863 LayerTestResult<T, 4> SimpleMaxPooling2dSize2x2Stride2x2TestCommon(
864  armnn::IWorkloadFactory& workloadFactory,
865  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
866  const armnn::ITensorHandleFactory& tensorHandleFactory,
867  bool forceNoPadding,
868  float qScale = 1.0f,
869  int32_t qOffset = 0)
870 {
871  armnn::Pooling2dDescriptor descriptor;
872  descriptor.m_PoolType = armnn::PoolingAlgorithm::Max;
873  descriptor.m_PoolWidth = descriptor.m_PoolHeight = 2;
874  descriptor.m_StrideX = 2;
875  descriptor.m_StrideY = 2;
876  descriptor.m_PadLeft = descriptor.m_PadRight = forceNoPadding ? 0 : 3;
877  descriptor.m_PadTop = descriptor.m_PadBottom = 0;
878  descriptor.m_OutputShapeRounding = armnn::OutputShapeRounding::Floor;
879  descriptor.m_PaddingMethod = armnn::PaddingMethod::Exclude;
880 
881 
882  unsigned int inputWidth = 4;
883 
884  unsigned int inputHeight = 4;
885 
886  unsigned int outputWidth =
887  (inputWidth + descriptor.m_PadLeft + descriptor.m_PadRight + descriptor.m_StrideX - descriptor.m_PoolWidth) /
888  descriptor.m_StrideX;
889  unsigned int outputHeight =
890  (inputHeight + descriptor.m_PadTop + descriptor.m_PadBottom + descriptor.m_StrideY - descriptor.m_PoolHeight) /
891  descriptor.m_StrideY;
892  unsigned int channels = 1;
893  unsigned int batchSize = 1;
894 
895  std::vector<float> inputData = {
896  510.0f, 222.0f, 780.0f, 654.0f,
897  141.0f, 276.0f, 15.0f, 546.0f,
898  303.0f, 618.0f, 582.0f, 339.0f,
899  438.0f, 564.0f, 573.0f, 402.0f
900  };
901 
902  // Note that left and right edges will be 0.f, due to the 2x2 max pooling only accessing zeros here.
903  std::vector<float> expectedOutputDataWithPadding = {
904  0.0f, 510.0f, 780.0f, 654.0f, 0.0f,
905  0.0f, 438.0f, 618.0f, 402.0f, 0.0f
906  };
907 
908  std::vector<float> expectedOutputDataNoPadding = {
909  510.0f, 780.0f,
910  618.0f, 582.0f
911  };
912 
913  armnn::TensorInfo inputTensorInfo({ batchSize, channels, inputHeight, inputWidth }, ArmnnType);
914 
915  // Scale and offset should match input - we're just calculating maximum values.
916  armnn::TensorInfo outputTensorInfo({ batchSize, channels, outputHeight, outputWidth }, ArmnnType);
917 
918  // Set quantization parameters if the requested type is a quantized type.
919  if(armnn::IsQuantizedType<T>())
920  {
921  inputTensorInfo.SetQuantizationScale(qScale);
922  inputTensorInfo.SetQuantizationOffset(qOffset);
923  outputTensorInfo.SetQuantizationScale(qScale);
924  outputTensorInfo.SetQuantizationOffset(qOffset);
925  }
926 
927  auto input = MakeTensor<T, 4>(inputTensorInfo, QuantizedVector<T>(inputData, qScale, qOffset));
928 
929  auto outputExpected = MakeTensor<T, 4>(outputTensorInfo,
930  forceNoPadding ? QuantizedVector<T>(expectedOutputDataNoPadding, qScale, qOffset) :
931  QuantizedVector<T>(expectedOutputDataWithPadding, qScale, qOffset));
932 
933  return SimplePooling2dTestImpl<ArmnnType>(
934  workloadFactory, memoryManager, tensorHandleFactory, descriptor, qScale, qOffset, input, outputExpected);
935 }
936 
937 //
938 // Tests max pooling with the following parameters:
939 //
940 // Pooling size: 3x2
941 // Stride: (2,2)
942 // input size: 3x2
943 // channels: 1
944 // batch size: 1
945 //
946 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
947 LayerTestResult<T, 4> IgnorePaddingAveragePooling2dSize3x2Stride2x2TestCommon(
948  armnn::IWorkloadFactory& workloadFactory,
949  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
950  const armnn::ITensorHandleFactory& tensorHandleFactory,
951  bool forceNoPadding,
952  float qScale = 1.0f,
953  int32_t qOffset = 0)
954 {
955  armnn::Pooling2dDescriptor descriptor;
956  descriptor.m_PoolType = armnn::PoolingAlgorithm::Average;
957  descriptor.m_PoolWidth = 3;
958  descriptor.m_PoolHeight = 2;
959  descriptor.m_StrideX = 2;
960  descriptor.m_StrideY = 2;
961  descriptor.m_PadLeft = (forceNoPadding) ? 0 : 1;
962  descriptor.m_PadRight = descriptor.m_PadLeft;
963  descriptor.m_PadTop = 0;
964  descriptor.m_PadBottom = 0;
965  descriptor.m_OutputShapeRounding = armnn::OutputShapeRounding::Floor;
966  descriptor.m_PaddingMethod = armnn::PaddingMethod::IgnoreValue;
967 
968  unsigned int inputWidth = 3;
969  unsigned int inputHeight = 2;
970  unsigned int outputWidth =
971  (inputWidth + descriptor.m_PadLeft + descriptor.m_PadRight + descriptor.m_StrideX - descriptor.m_PoolWidth) /
972  descriptor.m_StrideX;
973  unsigned int outputHeight =
974  (inputHeight + descriptor.m_PadTop + descriptor.m_PadBottom + descriptor.m_StrideY - descriptor.m_PoolHeight) /
975  descriptor.m_StrideY;
976  unsigned int channels = 1;
977  unsigned int batchSize = 1;
978 
979  std::vector<float> inputData = {
980  3.0f, 6.0f, 9.0f,
981  12.0f, 15.0f, 18.0f,
982  };
983 
984  std::vector<float> expectedOutputDataWithPadding = {
985  6.0f, 8.0f,
986  };
987 
988  std::vector<float> expectedOutputDataNoPadding = {
989  10.5f,
990  };
991 
992  armnn::TensorInfo inputTensorInfo({ batchSize, channels, inputHeight, inputWidth }, ArmnnType);
993 
994  // Scale and offset should match input - we're just calculating average values.
995  armnn::TensorInfo outputTensorInfo({ batchSize, channels, outputHeight, outputWidth }, ArmnnType);
996 
997  // Set quantization parameters if the requested type is a quantized type.
998  if(armnn::IsQuantizedType<T>())
999  {
1000  inputTensorInfo.SetQuantizationScale(qScale);
1001  inputTensorInfo.SetQuantizationOffset(qOffset);
1002  outputTensorInfo.SetQuantizationScale(qScale);
1003  outputTensorInfo.SetQuantizationOffset(qOffset);
1004  }
1005 
1006  auto input = MakeTensor<T, 4>(inputTensorInfo, QuantizedVector<T>(inputData, qScale, qOffset));
1007 
1008  auto outputExpected = MakeTensor<T, 4>(outputTensorInfo,
1009  forceNoPadding ? QuantizedVector<T>(expectedOutputDataNoPadding, qScale, qOffset) :
1010  QuantizedVector<T>(expectedOutputDataWithPadding, qScale, qOffset));
1011 
1012  return SimplePooling2dTestImpl<ArmnnType>(
1013  workloadFactory, memoryManager, tensorHandleFactory, descriptor, qScale, qOffset, input, outputExpected);
1014 }
1015 
1016 
1017 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
1018 LayerTestResult<T, 4> IgnorePaddingSimpleMaxPooling2dTestCommon(
1019  armnn::IWorkloadFactory& workloadFactory,
1020  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1021  const armnn::ITensorHandleFactory& tensorHandleFactory,
1022  float qScale = 1.0f,
1023  int32_t qOffset = 0)
1024 {
1025  armnn::Pooling2dDescriptor descriptor;
1026  descriptor.m_PoolType = armnn::PoolingAlgorithm::Max;
1027  descriptor.m_PoolWidth = descriptor.m_PoolHeight = 2;
1028  descriptor.m_StrideX = descriptor.m_StrideY = 2;
1029  descriptor.m_PadLeft = 1;
1030  descriptor.m_PadRight = 1;
1031  descriptor.m_PadTop = 1;
1032  descriptor.m_PadBottom = 1;
1033  descriptor.m_PaddingMethod = armnn::PaddingMethod::IgnoreValue;
1034 
1035  armnn::TensorInfo inputTensorInfo({ 1, 1, 4, 4 }, ArmnnType);
1036  armnn::TensorInfo outputTensorInfo({ 1, 1, 3, 3 }, ArmnnType);
1037 
1038  // Set quantization parameters if the requested type is a quantized type.
1039  if(armnn::IsQuantizedType<T>())
1040  {
1041  inputTensorInfo.SetQuantizationScale(qScale);
1042  inputTensorInfo.SetQuantizationOffset(qOffset);
1043  outputTensorInfo.SetQuantizationScale(qScale);
1044  outputTensorInfo.SetQuantizationOffset(qOffset);
1045  }
1046 
1047  auto input = MakeTensor<T, 4>(inputTensorInfo,
1048  QuantizedVector<T>({
1049  -1.0f, -2.0f, 3.0f, 4.0f,
1050  -1.0f, -2.0f, 3.0f, 4.0f,
1051  1.0f, 2.0f, -3.0f, -4.0f,
1052  1.0f, 2.0f, -3.0f, -4.0f,
1053  },
1054  qScale, qOffset));
1055 
1056  auto outputExpected = MakeTensor<T, 4>(outputTensorInfo,
1057  QuantizedVector<T>({
1058  -1.0f, 3.0f, 4.0f,
1059  1.0f, 3.0f, 4.0f,
1060  1.0f, 2.0f, -4.0f,
1061  },
1062  qScale, qOffset));
1063 
1064  return SimplePooling2dTestImpl<ArmnnType>(
1065  workloadFactory, memoryManager, tensorHandleFactory, descriptor, qScale, qOffset, input, outputExpected);
1066 }
1067 
1068 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
1069 LayerTestResult<T, 4> IgnorePaddingMaxPooling2dSize3TestCommon(
1070  armnn::IWorkloadFactory& workloadFactory,
1071  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1072  const armnn::ITensorHandleFactory& tensorHandleFactory,
1073  float qScale = 1.0f,
1074  int32_t qOffset = 0)
1075 {
1076  armnn::Pooling2dDescriptor descriptor;
1077  descriptor.m_PoolType = armnn::PoolingAlgorithm::Max;
1078  descriptor.m_PoolWidth = descriptor.m_PoolHeight = 3;
1079  descriptor.m_StrideX = descriptor.m_StrideY = 1;
1080  descriptor.m_PadLeft = 1;
1081  descriptor.m_PadRight = 1;
1082  descriptor.m_PadTop = 1;
1083  descriptor.m_PadBottom = 1;
1084  descriptor.m_PaddingMethod = armnn::PaddingMethod::IgnoreValue;
1085 
1086  armnn::TensorInfo inputTensorInfo({ 1, 1, 4, 4 }, ArmnnType);
1087  armnn::TensorInfo outputTensorInfo({ 1, 1, 4, 4 }, ArmnnType);
1088 
1089  // Set quantization parameters if the requested type is a quantized type.
1090  if(armnn::IsQuantizedType<T>())
1091  {
1092  inputTensorInfo.SetQuantizationScale(qScale);
1093  inputTensorInfo.SetQuantizationOffset(qOffset);
1094  outputTensorInfo.SetQuantizationScale(qScale);
1095  outputTensorInfo.SetQuantizationOffset(qOffset);
1096  }
1097 
1098  auto input = MakeTensor<T, 4>(inputTensorInfo,
1099  QuantizedVector<T>({
1100  -1.0f, -2.0f, 3.0f, 4.0f,
1101  -1.0f, -2.0f, 3.0f, 4.0f,
1102  1.0f, 2.0f, -3.0f, -4.0f,
1103  1.0f, 2.0f, -3.0f, -4.0f,
1104  },
1105  qScale, qOffset));
1106 
1107  auto outputExpected = MakeTensor<T, 4>(outputTensorInfo,
1108  QuantizedVector<T>({
1109  -1.0f, 3.0f, 4.0f, 4.0f,
1110  2.0f, 3.0f, 4.0f, 4.0f,
1111  2.0f, 3.0f, 4.0f, 4.0f,
1112  2.0f, 2.0f, 2.0f, -3.0f,
1113  },
1114  qScale, qOffset));
1115 
1116  return SimplePooling2dTestImpl<ArmnnType>(
1117  workloadFactory, memoryManager, tensorHandleFactory, descriptor, qScale, qOffset, input, outputExpected);
1118 }
1119 
1120 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
1121 LayerTestResult<T, 4> IgnorePaddingSimpleAveragePooling2dTestCommon(
1122  armnn::IWorkloadFactory& workloadFactory,
1123  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1124  const armnn::ITensorHandleFactory& tensorHandleFactory,
1125  float qScale = 1.0f,
1126  int32_t qOffset = 0)
1127 {
1128  armnn::Pooling2dDescriptor descriptor;
1129  descriptor.m_PoolType = armnn::PoolingAlgorithm::Average;
1130  descriptor.m_PoolWidth = descriptor.m_PoolHeight = 2;
1131  descriptor.m_StrideX = descriptor.m_StrideY = 2;
1132  descriptor.m_PadLeft = 1;
1133  descriptor.m_PadRight = 1;
1134  descriptor.m_PadTop = 1;
1135  descriptor.m_PadBottom = 1;
1136  descriptor.m_PaddingMethod = armnn::PaddingMethod::IgnoreValue;
1137 
1138  armnn::TensorInfo inputTensorInfo({ 1, 1, 4, 4 }, ArmnnType);
1139  armnn::TensorInfo outputTensorInfo({ 1, 1, 3, 3 }, ArmnnType);
1140 
1141  // Set quantization parameters if the requested type is a quantized type.
1142  if(armnn::IsQuantizedType<T>())
1143  {
1144  inputTensorInfo.SetQuantizationScale(qScale);
1145  inputTensorInfo.SetQuantizationOffset(qOffset);
1146  outputTensorInfo.SetQuantizationScale(qScale);
1147  outputTensorInfo.SetQuantizationOffset(qOffset);
1148  }
1149 
1150  auto input = MakeTensor<T, 4>(inputTensorInfo,
1151  QuantizedVector<T>({
1152  12.0f, 20.0f, 32.0f, 40.0f,
1153  12.0f, 20.0f, 32.0f, 40.0f,
1154  12.0f, 20.0f, 32.0f, 40.0f,
1155  12.0f, 20.0f, 32.0f, 40.0f,
1156  },
1157  qScale, qOffset));
1158 
1159  auto outputExpected = MakeTensor<T, 4>(outputTensorInfo,
1160  QuantizedVector<T>({
1161  3.0f, 13.0f, 10.0f,
1162  6.0f, 26.0f, 20.0f,
1163  3.0f, 13.0f, 10.0f,
1164  },
1165  qScale, qOffset));
1166 
1167  return SimplePooling2dTestImpl<ArmnnType>(
1168  workloadFactory, memoryManager, tensorHandleFactory, descriptor, qScale, qOffset, input, outputExpected);
1169 }
1170 
1171 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
1172 LayerTestResult<T, 4> IgnorePaddingSimpleAveragePooling2dNoPaddingTestCommon(
1173  armnn::IWorkloadFactory& workloadFactory,
1174  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1175  const armnn::ITensorHandleFactory& tensorHandleFactory,
1176  float qScale = 1.0f,
1177  int32_t qOffset = 0)
1178 {
1179  armnn::Pooling2dDescriptor descriptor;
1180  descriptor.m_PoolType = armnn::PoolingAlgorithm::Average;
1181  descriptor.m_PoolWidth = descriptor.m_PoolHeight = 3;
1182  descriptor.m_StrideX = descriptor.m_StrideY = 2;
1183  descriptor.m_PadLeft = 0;
1184  descriptor.m_PadRight = 0;
1185  descriptor.m_PadTop = 0;
1186  descriptor.m_PadBottom = 0;
1187  descriptor.m_PaddingMethod = armnn::PaddingMethod::IgnoreValue;
1188  descriptor.m_OutputShapeRounding = armnn::OutputShapeRounding::Ceiling;
1189 
1190  armnn::TensorInfo inputTensorInfo({ 1, 1, 4, 4}, ArmnnType);
1191  armnn::TensorInfo outputTensorInfo({ 1, 1, 2, 2 }, ArmnnType);
1192 
1193  // Set quantization parameters if the requested type is a quantized type.
1194  if(armnn::IsQuantizedType<T>())
1195  {
1196  inputTensorInfo.SetQuantizationScale(qScale);
1197  inputTensorInfo.SetQuantizationOffset(qOffset);
1198  outputTensorInfo.SetQuantizationScale(qScale);
1199  outputTensorInfo.SetQuantizationOffset(qOffset);
1200  }
1201 
1202  auto input = MakeTensor<T, 4>(inputTensorInfo,
1203  QuantizedVector<T>({
1204  1.0f, 2.0f, 3.0f, 4.0f,
1205  1.0f, 2.0f, 3.0f, 4.0f,
1206  1.0f, 2.0f, 3.0f, 4.0f,
1207  1.0f, 2.0f, 3.0f, 4.0f,
1208  },
1209  qScale, qOffset));
1210 
1211  auto outputExpected = MakeTensor<T, 4>(outputTensorInfo,
1212  QuantizedVector<T>({
1213  2.0f, 3.5f,
1214  2.0f, 3.5f
1215  },
1216  qScale, qOffset));
1217 
1218  return SimplePooling2dTestImpl<ArmnnType>(
1219  workloadFactory, memoryManager, tensorHandleFactory, descriptor, qScale, qOffset, input, outputExpected);
1220 }
1221 
1222 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
1223 LayerTestResult<T, 4> IgnorePaddingAveragePooling2dSize3TestCommon(
1224  armnn::IWorkloadFactory& workloadFactory,
1225  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1226  const armnn::ITensorHandleFactory& tensorHandleFactory,
1227  float qScale = 1.0f,
1228  int32_t qOffset = 0)
1229 {
1230  armnn::Pooling2dDescriptor descriptor;
1231  descriptor.m_PoolType = armnn::PoolingAlgorithm::Average;
1232  descriptor.m_PoolWidth = descriptor.m_PoolHeight = 3;
1233  descriptor.m_StrideX = descriptor.m_StrideY = 1;
1234  descriptor.m_PadLeft = 1;
1235  descriptor.m_PadRight = 1;
1236  descriptor.m_PadTop = 1;
1237  descriptor.m_PadBottom = 1;
1238  descriptor.m_PaddingMethod = armnn::PaddingMethod::IgnoreValue;
1239 
1240  armnn::TensorInfo inputTensorInfo({ 1, 1, 4, 4 }, ArmnnType);
1241  armnn::TensorInfo outputTensorInfo({ 1, 1, 4, 4 }, ArmnnType);
1242 
1243  // Set quantization parameters if the requested type is a quantized type.
1244  if(armnn::IsQuantizedType<T>())
1245  {
1246  inputTensorInfo.SetQuantizationScale(qScale);
1247  inputTensorInfo.SetQuantizationOffset(qOffset);
1248  outputTensorInfo.SetQuantizationScale(qScale);
1249  outputTensorInfo.SetQuantizationOffset(qOffset);
1250  }
1251 
1252  auto input = MakeTensor<T, 4>(inputTensorInfo,
1253  QuantizedVector<T>({
1254  9.0f, 27.0f, 18.0f, 36.0f,
1255  18.0f, 9.0f, 18.0f, 9.0f,
1256  27.0f, 18.0f, 9.0f, 27.0f,
1257  9.0f, 27.0f, 9.0f, 18.0f,
1258  },
1259  qScale, qOffset));
1260 
1261  auto outputExpected = MakeTensor<T, 4>(outputTensorInfo,
1262  QuantizedVector<T>({
1263  7.0f, 11.0f, 13.0f, 9.0f,
1264  12.0f, 17.0f, 19.0f, 13.0f,
1265  12.0f, 16.0f, 16.0f, 10.0f,
1266  9.0f, 11.0f, 12.0f, 7.0f,
1267  },
1268  qScale, qOffset));
1269 
1270  return SimplePooling2dTestImpl<ArmnnType>(
1271  workloadFactory, memoryManager, tensorHandleFactory, descriptor, qScale, qOffset, input, outputExpected);
1272 }
1273 
1274 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
1275 LayerTestResult<T, 4> IgnorePaddingSimpleL2Pooling2dTestCommon(
1276  armnn::IWorkloadFactory& workloadFactory,
1277  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1278  const armnn::ITensorHandleFactory& tensorHandleFactory,
1279  float qScale = 1.0f,
1280  int32_t qOffset = 0)
1281 {
1282  armnn::Pooling2dDescriptor descriptor;
1283  descriptor.m_PoolType = armnn::PoolingAlgorithm::L2;
1284  descriptor.m_PoolWidth = descriptor.m_PoolHeight = 2;
1285  descriptor.m_StrideX = descriptor.m_StrideY = 2;
1286  descriptor.m_PadLeft = 1;
1287  descriptor.m_PadRight = 1;
1288  descriptor.m_PadTop = 1;
1289  descriptor.m_PadBottom = 1;
1290  descriptor.m_PaddingMethod = armnn::PaddingMethod::IgnoreValue;
1291 
1292  armnn::TensorInfo inputTensorInfo({ 1, 1, 4, 4 }, ArmnnType);
1293  armnn::TensorInfo outputTensorInfo({ 1, 1, 3, 3 }, ArmnnType);
1294 
1295  // Set quantization parameters if the requested type is a quantized type.
1296  if(armnn::IsQuantizedType<T>())
1297  {
1298  inputTensorInfo.SetQuantizationScale(qScale);
1299  inputTensorInfo.SetQuantizationOffset(qOffset);
1300  outputTensorInfo.SetQuantizationScale(qScale);
1301  outputTensorInfo.SetQuantizationOffset(qOffset);
1302  }
1303 
1304  auto input = MakeTensor<T, 4>(inputTensorInfo,
1305  QuantizedVector<T>({
1306  2.0f, 4.0f, 8.0f, 16.0f,
1307  4.0f, 2.0f, 2.0f, 4.0f,
1308  8.0f, 2.0f, 4.0f, 2.0f,
1309  16.0f, 2.0f, 2.0f, 8.0f,
1310  },
1311  qScale, qOffset));
1312 
1313  auto outputExpected = MakeTensor<T, 4>(outputTensorInfo,
1314  QuantizedVector<T>({
1315  1.0f, 4.4721f, 8.0f,
1316  4.4721f, 2.6457f, 2.236f,
1317  8.0f, 1.4142f, 4.0f,
1318  },
1319  qScale, qOffset));
1320 
1321  return SimplePooling2dTestImpl<ArmnnType>(
1322  workloadFactory, memoryManager, tensorHandleFactory, descriptor, qScale, qOffset, input, outputExpected);
1323 }
1324 
1325 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
1326 LayerTestResult<T, 4> IgnorePaddingL2Pooling2dSize3TestCommon(
1327  armnn::IWorkloadFactory& workloadFactory,
1328  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1329  const armnn::ITensorHandleFactory& tensorHandleFactory,
1330  float qScale = 1.0f,
1331  int32_t qOffset = 0)
1332 {
1333  armnn::Pooling2dDescriptor descriptor;
1334  descriptor.m_PoolType = armnn::PoolingAlgorithm::L2;
1335  descriptor.m_PoolWidth = descriptor.m_PoolHeight = 3;
1336  descriptor.m_StrideX = descriptor.m_StrideY = 1;
1337  descriptor.m_PadLeft = 1;
1338  descriptor.m_PadRight = 1;
1339  descriptor.m_PadTop = 1;
1340  descriptor.m_PadBottom = 1;
1341  descriptor.m_PaddingMethod = armnn::PaddingMethod::IgnoreValue;
1342 
1343  armnn::TensorInfo inputTensorInfo({ 1, 1, 4, 4 }, ArmnnType);
1344  armnn::TensorInfo outputTensorInfo({ 1, 1, 4, 4 }, ArmnnType);
1345 
1346  // Set quantization parameters if the requested type is a quantized type.
1347  if(armnn::IsQuantizedType<T>())
1348  {
1349  inputTensorInfo.SetQuantizationScale(qScale);
1350  inputTensorInfo.SetQuantizationOffset(qOffset);
1351  outputTensorInfo.SetQuantizationScale(qScale);
1352  outputTensorInfo.SetQuantizationOffset(qOffset);
1353  }
1354 
1355  auto input = MakeTensor<T, 4>(inputTensorInfo,
1356  QuantizedVector<T>({
1357  1.0f, 2.0f, 3.0f, 4.0f,
1358  1.0f, 2.0f, 3.0f, 4.0f,
1359  1.0f, 2.0f, 3.0f, 4.0f,
1360  1.0f, 2.0f, 3.0f, 4.0f,
1361  },
1362  qScale, qOffset));
1363 
1364  auto outputExpected = MakeTensor<T, 4>(outputTensorInfo,
1365  QuantizedVector<T>({
1366  1.0540f, 1.7638f, 2.5385f, 2.3570f,
1367  1.2909f, 2.1602f, 3.1091f, 2.8867f,
1368  1.2909f, 2.1602f, 3.1091f, 2.8867f,
1369  1.0540f, 1.7638f, 2.5385f, 2.3570f,
1370  },
1371  qScale, qOffset));
1372 
1373  return SimplePooling2dTestImpl<ArmnnType>(
1374  workloadFactory, memoryManager, tensorHandleFactory, descriptor, qScale, qOffset, input, outputExpected);
1375 }
1376 
1377 } // anonymous namespace
1378 
1379 LayerTestResult<float, 4> SimpleMaxPooling2dSize2x2Stride2x2Test(
1380  armnn::IWorkloadFactory& workloadFactory,
1381  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1382  const armnn::ITensorHandleFactory& tensorHandleFactory,
1383  bool forceNoPadding)
1384 {
1385  return SimpleMaxPooling2dSize2x2Stride2x2TestCommon<armnn::DataType::Float32>(
1386  workloadFactory, memoryManager, tensorHandleFactory, forceNoPadding);
1387 }
1388 
1389 LayerTestResult<uint8_t, 4> SimpleMaxPooling2dSize2x2Stride2x2Uint8Test(
1390  armnn::IWorkloadFactory& workloadFactory,
1391  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1392  const armnn::ITensorHandleFactory& tensorHandleFactory,
1393  bool forceNoPadding)
1394 {
1395  return SimpleMaxPooling2dSize2x2Stride2x2TestCommon<armnn::DataType::QAsymmU8>(
1396  workloadFactory, memoryManager, tensorHandleFactory, forceNoPadding, 3.0f, -5);
1397 }
1398 
1399 LayerTestResult<int16_t, 4> SimpleMaxPooling2dSize2x2Stride2x2Int16Test(
1400  armnn::IWorkloadFactory& workloadFactory,
1401  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1402  const armnn::ITensorHandleFactory& tensorHandleFactory,
1403  bool forceNoPadding)
1404 {
1405  return SimpleMaxPooling2dSize2x2Stride2x2TestCommon<armnn::DataType::QSymmS16>(
1406  workloadFactory, memoryManager, tensorHandleFactory, forceNoPadding);
1407 }
1408 
1409 LayerTestResult<float, 4> SimpleMaxPooling2dSize3x3Stride2x4Test(
1410  armnn::IWorkloadFactory& workloadFactory,
1411  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1412  const armnn::ITensorHandleFactory& tensorHandleFactory,
1413  bool forceNoPadding)
1414 {
1415  return SimpleMaxPooling2dSize3x3Stride2x4TestCommon<armnn::DataType::Float32>(
1416  workloadFactory, memoryManager, tensorHandleFactory, forceNoPadding);
1417 }
1418 
1419 LayerTestResult<uint8_t, 4> SimpleMaxPooling2dSize3x3Stride2x4Uint8Test(
1420  armnn::IWorkloadFactory& workloadFactory,
1421  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1422  const armnn::ITensorHandleFactory& tensorHandleFactory,
1423  bool forceNoPadding)
1424 {
1425  return SimpleMaxPooling2dSize3x3Stride2x4TestCommon<armnn::DataType::QAsymmU8>(
1426  workloadFactory, memoryManager, tensorHandleFactory, forceNoPadding, 0.1f, 128);
1427 }
1428 
1429 LayerTestResult<int16_t, 4> SimpleMaxPooling2dSize3x3Stride2x4Int16Test(
1430  armnn::IWorkloadFactory& workloadFactory,
1431  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1432  const armnn::ITensorHandleFactory& tensorHandleFactory,
1433  bool forceNoPadding)
1434 {
1435  return SimpleMaxPooling2dSize3x3Stride2x4TestCommon<armnn::DataType::QSymmS16>(
1436  workloadFactory, memoryManager, tensorHandleFactory, forceNoPadding);
1437 }
1438 
1439 LayerTestResult<float, 4> SimpleMaxPooling2dTest(
1440  armnn::IWorkloadFactory& workloadFactory,
1441  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1442  const armnn::ITensorHandleFactory& tensorHandleFactory,
1443  const armnn::DataLayout dataLayout)
1444 {
1445  return SimpleMaxPooling2dTestCommon<armnn::DataType::Float32>(
1446  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1447 }
1448 
1449 LayerTestResult<uint8_t, 4> SimpleMaxPooling2dUint8Test(
1450  armnn::IWorkloadFactory& workloadFactory,
1451  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1452  const armnn::ITensorHandleFactory& tensorHandleFactory,
1453  const armnn::DataLayout dataLayout)
1454 {
1455  return SimpleMaxPooling2dTestCommon<armnn::DataType::QAsymmU8>(
1456  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1457 }
1458 
1459 LayerTestResult<int16_t, 4> SimpleMaxPooling2dInt16Test(
1460  armnn::IWorkloadFactory& workloadFactory,
1461  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1462  const armnn::ITensorHandleFactory& tensorHandleFactory,
1463  const armnn::DataLayout dataLayout)
1464 {
1465  return SimpleMaxPooling2dTestCommon<armnn::DataType::QSymmS16>(
1466  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1467 }
1468 LayerTestResult<float, 4> IgnorePaddingSimpleMaxPooling2dTest(
1469  armnn::IWorkloadFactory& workloadFactory,
1470  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1471  const armnn::ITensorHandleFactory& tensorHandleFactory)
1472 {
1473  return IgnorePaddingSimpleMaxPooling2dTestCommon<armnn::DataType::Float32>(
1474  workloadFactory, memoryManager, tensorHandleFactory);
1475 }
1476 
1477 LayerTestResult<uint8_t, 4> IgnorePaddingSimpleMaxPooling2dUint8Test(
1478  armnn::IWorkloadFactory& workloadFactory,
1479  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1480  const armnn::ITensorHandleFactory& tensorHandleFactory)
1481 {
1482  return IgnorePaddingSimpleMaxPooling2dTestCommon<armnn::DataType::QAsymmU8>(
1483  workloadFactory, memoryManager, tensorHandleFactory, 1.0f, -5);
1484 }
1485 
1486 LayerTestResult<int16_t, 4> IgnorePaddingSimpleMaxPooling2dInt16Test(
1487  armnn::IWorkloadFactory& workloadFactory,
1488  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1489  const armnn::ITensorHandleFactory& tensorHandleFactory)
1490 {
1491  return IgnorePaddingSimpleMaxPooling2dTestCommon<armnn::DataType::QSymmS16>(
1492  workloadFactory, memoryManager, tensorHandleFactory);
1493 }
1494 
1495 LayerTestResult<float, 4> IgnorePaddingMaxPooling2dSize3Test(
1496  armnn::IWorkloadFactory& workloadFactory,
1497  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1498  const armnn::ITensorHandleFactory& tensorHandleFactory)
1499 {
1500  return IgnorePaddingMaxPooling2dSize3TestCommon<armnn::DataType::Float32>(
1501  workloadFactory, memoryManager, tensorHandleFactory);
1502 }
1503 
1504 LayerTestResult<uint8_t, 4> IgnorePaddingMaxPooling2dSize3Uint8Test(
1505  armnn::IWorkloadFactory& workloadFactory,
1506  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1507  const armnn::ITensorHandleFactory& tensorHandleFactory)
1508 {
1509  return IgnorePaddingMaxPooling2dSize3TestCommon<armnn::DataType::QAsymmU8>(
1510  workloadFactory, memoryManager, tensorHandleFactory, 1.0f, -5);
1511 }
1512 
1513 LayerTestResult<int16_t, 4> IgnorePaddingMaxPooling2dSize3Int16Test(
1514  armnn::IWorkloadFactory& workloadFactory,
1515  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1516  const armnn::ITensorHandleFactory& tensorHandleFactory)
1517 {
1518  return IgnorePaddingMaxPooling2dSize3TestCommon<armnn::DataType::QSymmS16>(
1519  workloadFactory, memoryManager, tensorHandleFactory);
1520 }
1521 
1522 LayerTestResult<float, 4> SimpleAveragePooling2dTest(
1523  armnn::IWorkloadFactory& workloadFactory,
1524  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1525  const armnn::ITensorHandleFactory& tensorHandleFactory,
1526  const armnn::DataLayout dataLayout)
1527 {
1528  return SimpleAveragePooling2dTestCommon<armnn::DataType::Float32>(
1529  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1530 }
1531 
1532 LayerTestResult<uint8_t, 4> SimpleAveragePooling2dUint8Test(
1533  armnn::IWorkloadFactory& workloadFactory,
1534  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1535  const armnn::ITensorHandleFactory& tensorHandleFactory,
1536  const armnn::DataLayout dataLayout)
1537 {
1538  return SimpleAveragePooling2dTestCommon<armnn::DataType::QAsymmU8>(
1539  workloadFactory, memoryManager, tensorHandleFactory, dataLayout, 0.5, -1);
1540 }
1541 
1542 LayerTestResult<int16_t, 4> SimpleAveragePooling2dInt16Test(
1543  armnn::IWorkloadFactory& workloadFactory,
1544  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1545  const armnn::ITensorHandleFactory& tensorHandleFactory,
1546  const armnn::DataLayout dataLayout)
1547 {
1548  return SimpleAveragePooling2dTestCommon<armnn::DataType::QSymmS16>(
1549  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1550 }
1551 
1552 LayerTestResult<float, 4> IgnorePaddingAveragePooling2dSize3x2Stride2x2Test(
1553  armnn::IWorkloadFactory& workloadFactory,
1554  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1555  const armnn::ITensorHandleFactory& tensorHandleFactory,
1556  bool forceNoPadding)
1557 {
1558  return IgnorePaddingAveragePooling2dSize3x2Stride2x2TestCommon<armnn::DataType::Float32>(
1559  workloadFactory, memoryManager, tensorHandleFactory, forceNoPadding);
1560 }
1561 
1562 LayerTestResult<float, 4> LargeTensorsAveragePooling2dTest(
1563  armnn::IWorkloadFactory& workloadFactory,
1564  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1565  const armnn::ITensorHandleFactory& tensorHandleFactory)
1566 {
1567  return LargeTensorsAveragePooling2dTestCommon<armnn::DataType::Float32>(
1568  workloadFactory, memoryManager, tensorHandleFactory);
1569 }
1570 
1571 LayerTestResult<uint8_t, 4> LargeTensorsAveragePooling2dUint8Test(
1572  armnn::IWorkloadFactory& workloadFactory,
1573  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1574  const armnn::ITensorHandleFactory& tensorHandleFactory)
1575 {
1576  return LargeTensorsAveragePooling2dTestCommon<armnn::DataType::QAsymmU8>(
1577  workloadFactory, memoryManager, tensorHandleFactory, 0.5, -1);
1578 }
1579 
1580 LayerTestResult<int16_t, 4> LargeTensorsAveragePooling2dInt16Test(
1581  armnn::IWorkloadFactory& workloadFactory,
1582  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1583  const armnn::ITensorHandleFactory& tensorHandleFactory)
1584 {
1585  return LargeTensorsAveragePooling2dTestCommon<armnn::DataType::QSymmS16>(
1586  workloadFactory, memoryManager, tensorHandleFactory);
1587 }
1588 LayerTestResult<float, 4> IgnorePaddingSimpleAveragePooling2dTest(
1589  armnn::IWorkloadFactory& workloadFactory,
1590  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1591  const armnn::ITensorHandleFactory& tensorHandleFactory)
1592 {
1593  return IgnorePaddingSimpleAveragePooling2dTestCommon<armnn::DataType::Float32>(
1594  workloadFactory, memoryManager, tensorHandleFactory);
1595 }
1596 
1597 LayerTestResult<uint8_t, 4> IgnorePaddingSimpleAveragePooling2dUint8Test(
1598  armnn::IWorkloadFactory& workloadFactory,
1599  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1600  const armnn::ITensorHandleFactory& tensorHandleFactory)
1601 {
1602  return IgnorePaddingSimpleAveragePooling2dTestCommon<armnn::DataType::QAsymmU8>(
1603  workloadFactory, memoryManager, tensorHandleFactory);
1604 }
1605 
1606 LayerTestResult<int16_t, 4> IgnorePaddingSimpleAveragePooling2dInt16Test(
1607  armnn::IWorkloadFactory& workloadFactory,
1608  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1609  const armnn::ITensorHandleFactory& tensorHandleFactory)
1610 {
1611  return IgnorePaddingSimpleAveragePooling2dTestCommon<armnn::DataType::QSymmS16>(
1612  workloadFactory, memoryManager, tensorHandleFactory);
1613 }
1614 
1615 LayerTestResult<float, 4> IgnorePaddingSimpleAveragePooling2dNoPaddingTest(
1616  armnn::IWorkloadFactory& workloadFactory,
1617  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1618  const armnn::ITensorHandleFactory& tensorHandleFactory)
1619 {
1620  return IgnorePaddingSimpleAveragePooling2dNoPaddingTestCommon<armnn::DataType::Float32>(
1621  workloadFactory, memoryManager, tensorHandleFactory);
1622 }
1623 
1624 LayerTestResult<uint8_t, 4> IgnorePaddingSimpleAveragePooling2dNoPaddingUint8Test(
1625  armnn::IWorkloadFactory& workloadFactory,
1626  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1627  const armnn::ITensorHandleFactory& tensorHandleFactory)
1628 {
1629  return IgnorePaddingSimpleAveragePooling2dNoPaddingTestCommon<armnn::DataType::QAsymmU8>(
1630  workloadFactory, memoryManager, tensorHandleFactory);
1631 }
1632 
1633 LayerTestResult<int16_t, 4> IgnorePaddingSimpleAveragePooling2dNoPaddingInt16Test(
1634  armnn::IWorkloadFactory& workloadFactory,
1635  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1636  const armnn::ITensorHandleFactory& tensorHandleFactory)
1637 {
1638  return IgnorePaddingSimpleAveragePooling2dNoPaddingTestCommon<armnn::DataType::QSymmS16>(
1639  workloadFactory, memoryManager, tensorHandleFactory);
1640 }
1641 
1642 LayerTestResult<float, 4> IgnorePaddingAveragePooling2dSize3Test(
1643  armnn::IWorkloadFactory& workloadFactory,
1644  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1645  const armnn::ITensorHandleFactory& tensorHandleFactory)
1646 {
1647  return IgnorePaddingAveragePooling2dSize3TestCommon<armnn::DataType::Float32>(
1648  workloadFactory, memoryManager, tensorHandleFactory);
1649 }
1650 
1651 LayerTestResult<uint8_t, 4> IgnorePaddingAveragePooling2dSize3Uint8Test(
1652  armnn::IWorkloadFactory& workloadFactory,
1653  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1654  const armnn::ITensorHandleFactory& tensorHandleFactory)
1655 {
1656  return IgnorePaddingAveragePooling2dSize3TestCommon<armnn::DataType::QAsymmU8>(
1657  workloadFactory, memoryManager, tensorHandleFactory);
1658 }
1659 
1660 LayerTestResult<int16_t, 4> IgnorePaddingAveragePooling2dSize3Int16Test(
1661  armnn::IWorkloadFactory& workloadFactory,
1662  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1663  const armnn::ITensorHandleFactory& tensorHandleFactory)
1664 {
1665  return IgnorePaddingAveragePooling2dSize3TestCommon<armnn::DataType::QSymmS16>(
1666  workloadFactory, memoryManager, tensorHandleFactory);
1667 }
1668 
1669 LayerTestResult<float, 4> SimpleL2Pooling2dTest(
1670  armnn::IWorkloadFactory& workloadFactory,
1671  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1672  const armnn::ITensorHandleFactory& tensorHandleFactory,
1673  const armnn::DataLayout dataLayout)
1674 {
1675  return SimpleL2Pooling2dTestCommon<armnn::DataType::Float32>(
1676  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1677 }
1678 
1679 LayerTestResult<uint8_t, 4> SimpleL2Pooling2dUint8Test(
1680  armnn::IWorkloadFactory& workloadFactory,
1681  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1682  const armnn::ITensorHandleFactory& tensorHandleFactory,
1683  const armnn::DataLayout dataLayout)
1684 {
1685  return SimpleL2Pooling2dTestCommon<armnn::DataType::QAsymmU8>(
1686  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1687 }
1688 
1689 LayerTestResult<int16_t, 4> SimpleL2Pooling2dInt16Test(
1690  armnn::IWorkloadFactory& workloadFactory,
1691  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1692  const armnn::ITensorHandleFactory& tensorHandleFactory,
1693  const armnn::DataLayout dataLayout)
1694 {
1695  return SimpleL2Pooling2dTestCommon<armnn::DataType::QSymmS16>(
1696  workloadFactory, memoryManager, tensorHandleFactory, dataLayout);
1697 }
1698 
1699 LayerTestResult<float, 4> L2Pooling2dSize3Stride1Test(
1700  armnn::IWorkloadFactory& workloadFactory,
1701  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1702  const armnn::ITensorHandleFactory& tensorHandleFactory)
1703 {
1704  return L2Pooling2dSize3Stride1TestCommon<armnn::DataType::Float32>(
1705  workloadFactory, memoryManager, tensorHandleFactory);
1706 }
1707 
1708 LayerTestResult<uint8_t, 4> L2Pooling2dSize3Stride1Uint8Test(
1709  armnn::IWorkloadFactory& workloadFactory,
1710  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1711  const armnn::ITensorHandleFactory& tensorHandleFactory)
1712 {
1713  return L2Pooling2dSize3Stride1TestCommon<armnn::DataType::QAsymmU8>(
1714  workloadFactory, memoryManager, tensorHandleFactory);
1715 }
1716 
1717 LayerTestResult<int16_t, 4> L2Pooling2dSize3Stride1Int16Test(
1718  armnn::IWorkloadFactory& workloadFactory,
1719  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1720  const armnn::ITensorHandleFactory& tensorHandleFactory)
1721 {
1722  return L2Pooling2dSize3Stride1TestCommon<armnn::DataType::QSymmS16>(
1723  workloadFactory, memoryManager, tensorHandleFactory);
1724 }
1725 
1726 LayerTestResult<float, 4> L2Pooling2dSize3Stride3Test(
1727  armnn::IWorkloadFactory& workloadFactory,
1728  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1729  const armnn::ITensorHandleFactory& tensorHandleFactory)
1730 {
1731  return L2Pooling2dSize3Stride3TestCommon<armnn::DataType::Float32>(
1732  workloadFactory, memoryManager, tensorHandleFactory);
1733 }
1734 
1735 LayerTestResult<uint8_t, 4> L2Pooling2dSize3Stride3Uint8Test(
1736  armnn::IWorkloadFactory& workloadFactory,
1737  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1738  const armnn::ITensorHandleFactory& tensorHandleFactory)
1739 {
1740  return L2Pooling2dSize3Stride3TestCommon<armnn::DataType::QAsymmU8>(
1741  workloadFactory, memoryManager, tensorHandleFactory);
1742 }
1743 
1744 LayerTestResult<int16_t, 4> L2Pooling2dSize3Stride3Int16Test(
1745  armnn::IWorkloadFactory& workloadFactory,
1746  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1747  const armnn::ITensorHandleFactory& tensorHandleFactory)
1748 {
1749  return L2Pooling2dSize3Stride3TestCommon<armnn::DataType::QSymmS16>(
1750  workloadFactory, memoryManager, tensorHandleFactory);
1751 }
1752 LayerTestResult<float, 4> L2Pooling2dSize3Stride4Test(
1753  armnn::IWorkloadFactory& workloadFactory,
1754  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1755  const armnn::ITensorHandleFactory& tensorHandleFactory)
1756 {
1757  return L2Pooling2dSize3Stride4TestCommon<armnn::DataType::Float32>(
1758  workloadFactory, memoryManager, tensorHandleFactory);
1759 }
1760 
1761 LayerTestResult<uint8_t, 4> L2Pooling2dSize3Stride4Uint8Test(
1762  armnn::IWorkloadFactory& workloadFactory,
1763  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1764  const armnn::ITensorHandleFactory& tensorHandleFactory)
1765 {
1766  return L2Pooling2dSize3Stride4TestCommon<armnn::DataType::QAsymmU8>(
1767  workloadFactory, memoryManager, tensorHandleFactory);
1768 }
1769 
1770 LayerTestResult<int16_t, 4> L2Pooling2dSize3Stride4Int16Test(
1771  armnn::IWorkloadFactory& workloadFactory,
1772  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1773  const armnn::ITensorHandleFactory& tensorHandleFactory)
1774 {
1775  return L2Pooling2dSize3Stride4TestCommon<armnn::DataType::QSymmS16>(
1776  workloadFactory, memoryManager, tensorHandleFactory);
1777 }
1778 
1779 LayerTestResult<float, 4> L2Pooling2dSize7Test(
1780  armnn::IWorkloadFactory& workloadFactory,
1781  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1782  const armnn::ITensorHandleFactory& tensorHandleFactory)
1783 {
1784  return L2Pooling2dSize7TestCommon<armnn::DataType::Float32>(
1785  workloadFactory, memoryManager, tensorHandleFactory);
1786 }
1787 
1788 LayerTestResult<uint8_t, 4> L2Pooling2dSize7Uint8Test(
1789  armnn::IWorkloadFactory& workloadFactory,
1790  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1791  const armnn::ITensorHandleFactory& tensorHandleFactory)
1792 {
1793  return L2Pooling2dSize7TestCommon<armnn::DataType::QAsymmU8>(
1794  workloadFactory, memoryManager, tensorHandleFactory);
1795 }
1796 
1797 LayerTestResult<int16_t, 4> L2Pooling2dSize7Int16Test(
1798  armnn::IWorkloadFactory& workloadFactory,
1799  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1800  const armnn::ITensorHandleFactory& tensorHandleFactory)
1801 {
1802  return L2Pooling2dSize7TestCommon<armnn::DataType::QSymmS16>(
1803  workloadFactory, memoryManager, tensorHandleFactory);
1804 }
1805 
1806 LayerTestResult<float, 4> L2Pooling2dSize9Test(
1807  armnn::IWorkloadFactory& workloadFactory,
1808  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1809  const armnn::ITensorHandleFactory& tensorHandleFactory)
1810 {
1811  return L2Pooling2dSize9TestCommon<armnn::DataType::Float32>(
1812  workloadFactory, memoryManager, tensorHandleFactory);
1813 }
1814 
1815 LayerTestResult<uint8_t, 4> L2Pooling2dSize9Uint8Test(
1816  armnn::IWorkloadFactory& workloadFactory,
1817  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1818  const armnn::ITensorHandleFactory& tensorHandleFactory)
1819 {
1820  return L2Pooling2dSize9TestCommon<armnn::DataType::QAsymmU8>(
1821  workloadFactory, memoryManager, tensorHandleFactory);
1822 }
1823 
1824 LayerTestResult<int16_t, 4> L2Pooling2dSize9Int16Test(
1825  armnn::IWorkloadFactory& workloadFactory,
1826  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1827  const armnn::ITensorHandleFactory& tensorHandleFactory)
1828 {
1829  return L2Pooling2dSize9TestCommon<armnn::DataType::QSymmS16>(
1830  workloadFactory, memoryManager, tensorHandleFactory);
1831 }
1832 LayerTestResult<float, 4> IgnorePaddingSimpleL2Pooling2dTest(
1833  armnn::IWorkloadFactory& workloadFactory,
1834  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1835  const armnn::ITensorHandleFactory& tensorHandleFactory)
1836 {
1837  return IgnorePaddingSimpleL2Pooling2dTestCommon<armnn::DataType::Float32>(
1838  workloadFactory, memoryManager, tensorHandleFactory);
1839 }
1840 
1841 LayerTestResult<uint8_t, 4> IgnorePaddingSimpleL2Pooling2dUint8Test(
1842  armnn::IWorkloadFactory& workloadFactory,
1843  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1844  const armnn::ITensorHandleFactory& tensorHandleFactory)
1845 {
1846  return IgnorePaddingSimpleL2Pooling2dTestCommon<armnn::DataType::QAsymmU8>(
1847  workloadFactory, memoryManager, tensorHandleFactory);
1848 }
1849 
1850 LayerTestResult<int16_t, 4> IgnorePaddingSimpleL2Pooling2dInt16Test(
1851  armnn::IWorkloadFactory& workloadFactory,
1852  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1853  const armnn::ITensorHandleFactory& tensorHandleFactory)
1854 {
1855  return IgnorePaddingSimpleL2Pooling2dTestCommon<armnn::DataType::QSymmS16>(
1856  workloadFactory, memoryManager, tensorHandleFactory);
1857 }
1858 
1859 LayerTestResult<float, 4> IgnorePaddingL2Pooling2dSize3Test(
1860  armnn::IWorkloadFactory& workloadFactory,
1861  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1862  const armnn::ITensorHandleFactory& tensorHandleFactory)
1863 {
1864  return IgnorePaddingL2Pooling2dSize3TestCommon<armnn::DataType::Float32>(
1865  workloadFactory, memoryManager, tensorHandleFactory);
1866 }
1867 
1868 LayerTestResult<uint8_t, 4> IgnorePaddingL2Pooling2dSize3Uint8Test(
1869  armnn::IWorkloadFactory& workloadFactory,
1870  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1871  const armnn::ITensorHandleFactory& tensorHandleFactory)
1872 {
1873  return IgnorePaddingL2Pooling2dSize3TestCommon<armnn::DataType::QAsymmU8>(
1874  workloadFactory, memoryManager, tensorHandleFactory);
1875 }
1876 
1877 LayerTestResult<int16_t, 4> IgnorePaddingL2Pooling2dSize3Int16Test(
1878  armnn::IWorkloadFactory& workloadFactory,
1879  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1880  const armnn::ITensorHandleFactory& tensorHandleFactory)
1881 {
1882  return IgnorePaddingL2Pooling2dSize3TestCommon<armnn::DataType::QSymmS16>(
1883  workloadFactory, memoryManager, tensorHandleFactory);
1884 }
1885 
1886 LayerTestResult<float, 4> AsymmetricNonSquarePooling2dTest(
1887  armnn::IWorkloadFactory& workloadFactory,
1888  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1889  const armnn::ITensorHandleFactory& tensorHandleFactory)
1890 {
1891  return AsymmetricNonSquarePooling2dTestCommon<armnn::DataType::Float32>(
1892  workloadFactory, memoryManager, tensorHandleFactory);
1893 }
1894 
1895 LayerTestResult<uint8_t, 4> AsymmetricNonSquarePooling2dUint8Test(
1896  armnn::IWorkloadFactory& workloadFactory,
1897  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1898  const armnn::ITensorHandleFactory& tensorHandleFactory)
1899 {
1900  return AsymmetricNonSquarePooling2dTestCommon<armnn::DataType::QAsymmU8>(
1901  workloadFactory, memoryManager, tensorHandleFactory);
1902 }
1903 
1904 LayerTestResult<int16_t, 4> AsymmetricNonSquarePooling2dInt16Test(
1905  armnn::IWorkloadFactory& workloadFactory,
1906  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1907  const armnn::ITensorHandleFactory& tensorHandleFactory)
1908 {
1909  return AsymmetricNonSquarePooling2dTestCommon<armnn::DataType::QSymmS16>(
1910  workloadFactory, memoryManager, tensorHandleFactory);
1911 }
1912 
1913 LayerTestResult<float, 4> ComparePooling2dTest(
1914  armnn::IWorkloadFactory& workloadFactory,
1915  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1916  armnn::IWorkloadFactory& refWorkloadFactory,
1917  const armnn::ITensorHandleFactory& tensorHandleFactory,
1918  const armnn::ITensorHandleFactory& refTensorHandleFactory,
1919  armnn::PoolingAlgorithm poolingType)
1920 {
1921  return ComparePooling2dTestCommon<armnn::DataType::Float32>(
1922  workloadFactory, memoryManager, refWorkloadFactory, tensorHandleFactory, refTensorHandleFactory, poolingType);
1923 }
1924 
1925 LayerTestResult<uint8_t, 4> ComparePooling2dUint8Test(
1926  armnn::IWorkloadFactory& workloadFactory,
1927  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1928  armnn::IWorkloadFactory& refWorkloadFactory,
1929  const armnn::ITensorHandleFactory& tensorHandleFactory,
1930  const armnn::ITensorHandleFactory& refTensorHandleFactory,
1931  armnn::PoolingAlgorithm poolingType)
1932 {
1933  return ComparePooling2dTestCommon<armnn::DataType::QAsymmU8>(
1934  workloadFactory, memoryManager, refWorkloadFactory, tensorHandleFactory, refTensorHandleFactory,
1935  poolingType, 0.1f, 128);
1936 }
1937 
1938 LayerTestResult<int16_t, 4> ComparePooling2dInt16Test(
1939  armnn::IWorkloadFactory& workloadFactory,
1940  const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1941  armnn::IWorkloadFactory& refWorkloadFactory,
1942  const armnn::ITensorHandleFactory& tensorHandleFactory,
1943  const armnn::ITensorHandleFactory& refTensorHandleFactory,
1944  armnn::PoolingAlgorithm poolingType)
1945 {
1946  return ComparePooling2dTestCommon<armnn::DataType::QSymmS16>(
1947  workloadFactory, memoryManager, refWorkloadFactory, tensorHandleFactory, refTensorHandleFactory, poolingType);
1948 }
armnn::TensorShape::GetNumElements
unsigned int GetNumElements() const
Function that calculates the tensor elements by multiplying all dimension size which are Specified...
Definition: Tensor.cpp:181
L2Pooling2dSize3Stride1Uint8Test
LayerTestResult< uint8_t, 4 > L2Pooling2dSize3Stride1Uint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Definition: Pooling2dTestImpl.cpp:1708
IgnoreUnused.hpp
TensorCopyUtils.hpp
armnn::IWorkloadFactory::GetBackendId
virtual const BackendId & GetBackendId() const =0
SimpleL2Pooling2dInt16Test
LayerTestResult< int16_t, 4 > SimpleL2Pooling2dInt16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling2dTestImpl.cpp:1689
SimpleMaxPooling2dSize2x2Stride2x2Uint8Test
LayerTestResult< uint8_t, 4 > SimpleMaxPooling2dSize2x2Stride2x2Uint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, bool forceNoPadding)
Definition: Pooling2dTestImpl.cpp:1389
DataLayoutIndexed.hpp
armnn::Pooling2dDescriptor::m_PadBottom
uint32_t m_PadBottom
Padding bottom value in the height dimension.
Definition: Descriptors.hpp:371
armnn::DataLayout
DataLayout
Definition: Types.hpp:50
armnnUtils::DataLayoutIndexed::GetWidthIndex
unsigned int GetWidthIndex() const
Definition: DataLayoutIndexed.hpp:25
IgnorePaddingAveragePooling2dSize3Int16Test
LayerTestResult< int16_t, 4 > IgnorePaddingAveragePooling2dSize3Int16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Definition: Pooling2dTestImpl.cpp:1660
armnn::IsPooling2dSupported
bool IsPooling2dSupported(const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const Pooling2dDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
Definition: LayerSupport.cpp:542
IgnorePaddingAveragePooling2dSize3Test
LayerTestResult< float, 4 > IgnorePaddingAveragePooling2dSize3Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Definition: Pooling2dTestImpl.cpp:1642
armnn::TensorInfo::GetShape
const TensorShape & GetShape() const
Definition: Tensor.hpp:187
armnn::Pooling2dDescriptor::m_PadLeft
uint32_t m_PadLeft
Padding left value in the width dimension.
Definition: Descriptors.hpp:365
LargeTensorsAveragePooling2dInt16Test
LayerTestResult< int16_t, 4 > LargeTensorsAveragePooling2dInt16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Definition: Pooling2dTestImpl.cpp:1580
SimpleMaxPooling2dInt16Test
LayerTestResult< int16_t, 4 > SimpleMaxPooling2dInt16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling2dTestImpl.cpp:1459
IgnorePaddingSimpleMaxPooling2dInt16Test
LayerTestResult< int16_t, 4 > IgnorePaddingSimpleMaxPooling2dInt16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Definition: Pooling2dTestImpl.cpp:1486
QuantizeHelper.hpp
WorkloadTestUtils.hpp
SimpleMaxPooling2dUint8Test
LayerTestResult< uint8_t, 4 > SimpleMaxPooling2dUint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling2dTestImpl.cpp:1449
IgnorePaddingSimpleL2Pooling2dTest
LayerTestResult< float, 4 > IgnorePaddingSimpleL2Pooling2dTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Definition: Pooling2dTestImpl.cpp:1832
armnn::Pooling2dDescriptor::m_PoolWidth
uint32_t m_PoolWidth
Pooling width value.
Definition: Descriptors.hpp:373
IgnorePaddingL2Pooling2dSize3Uint8Test
LayerTestResult< uint8_t, 4 > IgnorePaddingL2Pooling2dSize3Uint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Definition: Pooling2dTestImpl.cpp:1868
armnn::PaddingMethod::Exclude
The padding fields don&#39;t count and are ignored.
armnn::Pooling2dDescriptor::m_PaddingMethod
PaddingMethod m_PaddingMethod
The padding method to be used. (Exclude, IgnoreValue).
Definition: Descriptors.hpp:383
IgnorePaddingL2Pooling2dSize3Test
LayerTestResult< float, 4 > IgnorePaddingL2Pooling2dSize3Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Definition: Pooling2dTestImpl.cpp:1859
SimpleMaxPooling2dSize2x2Stride2x2Test
LayerTestResult< float, 4 > SimpleMaxPooling2dSize2x2Stride2x2Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, bool forceNoPadding)
Definition: Pooling2dTestImpl.cpp:1379
armnn::Pooling2dDescriptor::m_PadTop
uint32_t m_PadTop
Padding top value in the height dimension.
Definition: Descriptors.hpp:369
SimpleMaxPooling2dSize3x3Stride2x4Int16Test
LayerTestResult< int16_t, 4 > SimpleMaxPooling2dSize3x3Stride2x4Int16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, bool forceNoPadding)
Definition: Pooling2dTestImpl.cpp:1429
ResolveType.hpp
IgnorePaddingSimpleAveragePooling2dNoPaddingUint8Test
LayerTestResult< uint8_t, 4 > IgnorePaddingSimpleAveragePooling2dNoPaddingUint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Definition: Pooling2dTestImpl.cpp:1624
SimpleMaxPooling2dTest
LayerTestResult< float, 4 > SimpleMaxPooling2dTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling2dTestImpl.cpp:1439
armnn::IgnoreUnused
void IgnoreUnused(Ts &&...)
Definition: IgnoreUnused.hpp:14
armnn::PoolingAlgorithm
PoolingAlgorithm
Definition: Types.hpp:104
L2Pooling2dSize9Test
LayerTestResult< float, 4 > L2Pooling2dSize9Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Definition: Pooling2dTestImpl.cpp:1806
ComparePooling2dInt16Test
LayerTestResult< int16_t, 4 > ComparePooling2dInt16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, armnn::IWorkloadFactory &refWorkloadFactory, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::ITensorHandleFactory &refTensorHandleFactory, armnn::PoolingAlgorithm poolingType)
Definition: Pooling2dTestImpl.cpp:1938
armnn::Pooling2dDescriptor::m_StrideX
uint32_t m_StrideX
Stride value when proceeding through input for the width dimension.
Definition: Descriptors.hpp:377
L2Pooling2dSize3Stride4Int16Test
LayerTestResult< int16_t, 4 > L2Pooling2dSize3Stride4Int16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Definition: Pooling2dTestImpl.cpp:1770
AsymmetricNonSquarePooling2dInt16Test
LayerTestResult< int16_t, 4 > AsymmetricNonSquarePooling2dInt16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Definition: Pooling2dTestImpl.cpp:1904
armnnUtils::DataLayoutIndexed::GetHeightIndex
unsigned int GetHeightIndex() const
Definition: DataLayoutIndexed.hpp:24
NumericCast.hpp
L2Pooling2dSize3Stride1Test
LayerTestResult< float, 4 > L2Pooling2dSize3Stride1Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Definition: Pooling2dTestImpl.cpp:1699
SimpleL2Pooling2dUint8Test
LayerTestResult< uint8_t, 4 > SimpleL2Pooling2dUint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling2dTestImpl.cpp:1679
ComparePooling2dUint8Test
LayerTestResult< uint8_t, 4 > ComparePooling2dUint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, armnn::IWorkloadFactory &refWorkloadFactory, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::ITensorHandleFactory &refTensorHandleFactory, armnn::PoolingAlgorithm poolingType)
Definition: Pooling2dTestImpl.cpp:1925
armnn::Pooling2dDescriptor::m_PoolHeight
uint32_t m_PoolHeight
Pooling height value.
Definition: Descriptors.hpp:375
armnnUtils::Permute
void Permute(const armnn::TensorShape &dstShape, const armnn::PermutationVector &mappings, const void *src, void *dst, size_t dataTypeSize)
Definition: Permute.cpp:131
SimpleL2Pooling2dTest
LayerTestResult< float, 4 > SimpleL2Pooling2dTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling2dTestImpl.cpp:1669
TensorHelpers.hpp
L2Pooling2dSize3Stride3Int16Test
LayerTestResult< int16_t, 4 > L2Pooling2dSize3Stride3Int16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Definition: Pooling2dTestImpl.cpp:1744
L2Pooling2dSize3Stride3Test
LayerTestResult< float, 4 > L2Pooling2dSize3Stride3Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Definition: Pooling2dTestImpl.cpp:1726
L2Pooling2dSize3Stride4Uint8Test
LayerTestResult< uint8_t, 4 > L2Pooling2dSize3Stride4Uint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Definition: Pooling2dTestImpl.cpp:1761
Permute.hpp
IgnorePaddingAveragePooling2dSize3x2Stride2x2Test
LayerTestResult< float, 4 > IgnorePaddingAveragePooling2dSize3x2Stride2x2Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, bool forceNoPadding)
Definition: Pooling2dTestImpl.cpp:1552
LargeTensorsAveragePooling2dTest
LayerTestResult< float, 4 > LargeTensorsAveragePooling2dTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Definition: Pooling2dTestImpl.cpp:1562
SimpleAveragePooling2dUint8Test
LayerTestResult< uint8_t, 4 > SimpleAveragePooling2dUint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling2dTestImpl.cpp:1532
armnn::Pooling2dDescriptor::m_PadRight
uint32_t m_PadRight
Padding right value in the width dimension.
Definition: Descriptors.hpp:367
SimpleAveragePooling2dTest
LayerTestResult< float, 4 > SimpleAveragePooling2dTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling2dTestImpl.cpp:1522
armnn::IBackendInternal::IMemoryManagerSharedPtr
std::shared_ptr< IMemoryManager > IMemoryManagerSharedPtr
Definition: IBackendInternal.hpp:92
armnnUtils::DataLayoutIndexed
Provides access to the appropriate indexes for Channels, Height and Width based on DataLayout...
Definition: DataLayoutIndexed.hpp:17
IgnorePaddingSimpleAveragePooling2dUint8Test
LayerTestResult< uint8_t, 4 > IgnorePaddingSimpleAveragePooling2dUint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Definition: Pooling2dTestImpl.cpp:1597
L2Pooling2dSize7Test
LayerTestResult< float, 4 > L2Pooling2dSize7Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Definition: Pooling2dTestImpl.cpp:1779
L2Pooling2dSize9Uint8Test
LayerTestResult< uint8_t, 4 > L2Pooling2dSize9Uint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Definition: Pooling2dTestImpl.cpp:1815
armnn::TensorInfo::SetQuantizationScale
void SetQuantizationScale(float scale)
Definition: Tensor.cpp:464
IgnorePaddingAveragePooling2dSize3Uint8Test
LayerTestResult< uint8_t, 4 > IgnorePaddingAveragePooling2dSize3Uint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Definition: Pooling2dTestImpl.cpp:1651
L2Pooling2dSize3Stride4Test
LayerTestResult< float, 4 > L2Pooling2dSize3Stride4Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Definition: Pooling2dTestImpl.cpp:1752
ComparePooling2dTest
LayerTestResult< float, 4 > ComparePooling2dTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, armnn::IWorkloadFactory &refWorkloadFactory, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::ITensorHandleFactory &refTensorHandleFactory, armnn::PoolingAlgorithm poolingType)
Definition: Pooling2dTestImpl.cpp:1913
CopyDataFromITensorHandle
void CopyDataFromITensorHandle(void *memory, const armnn::ITensorHandle *tensorHandle)
Definition: TensorCopyUtils.cpp:14
L2Pooling2dSize7Int16Test
LayerTestResult< int16_t, 4 > L2Pooling2dSize7Int16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Definition: Pooling2dTestImpl.cpp:1797
SimpleMaxPooling2dSize3x3Stride2x4Test
LayerTestResult< float, 4 > SimpleMaxPooling2dSize3x3Stride2x4Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, bool forceNoPadding)
Definition: Pooling2dTestImpl.cpp:1409
armnn::Pooling2dDescriptor::m_DataLayout
DataLayout m_DataLayout
The data layout to be used (NCHW, NHWC).
Definition: Descriptors.hpp:385
armnn::IWorkloadFactory::CreatePooling2d
virtual std::unique_ptr< IWorkload > CreatePooling2d(const Pooling2dQueueDescriptor &descriptor, const WorkloadInfo &info) const
Definition: WorkloadFactory.cpp:1567
AsymmetricNonSquarePooling2dUint8Test
LayerTestResult< uint8_t, 4 > AsymmetricNonSquarePooling2dUint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Definition: Pooling2dTestImpl.cpp:1895
AsymmetricNonSquarePooling2dTest
LayerTestResult< float, 4 > AsymmetricNonSquarePooling2dTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Definition: Pooling2dTestImpl.cpp:1886
IgnorePaddingSimpleAveragePooling2dInt16Test
LayerTestResult< int16_t, 4 > IgnorePaddingSimpleAveragePooling2dInt16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Definition: Pooling2dTestImpl.cpp:1606
IgnorePaddingSimpleMaxPooling2dUint8Test
LayerTestResult< uint8_t, 4 > IgnorePaddingSimpleMaxPooling2dUint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Definition: Pooling2dTestImpl.cpp:1477
LayerSupport.hpp
TensorUtils.hpp
armnn::Pooling2dDescriptor::m_PoolType
PoolingAlgorithm m_PoolType
The pooling algorithm to use (Max. Average, L2).
Definition: Descriptors.hpp:363
IgnorePaddingSimpleAveragePooling2dNoPaddingInt16Test
LayerTestResult< int16_t, 4 > IgnorePaddingSimpleAveragePooling2dNoPaddingInt16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Definition: Pooling2dTestImpl.cpp:1633
armnn::PaddingMethod::IgnoreValue
The padding fields count, but are ignored.
IgnorePaddingMaxPooling2dSize3Uint8Test
LayerTestResult< uint8_t, 4 > IgnorePaddingMaxPooling2dSize3Uint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Definition: Pooling2dTestImpl.cpp:1504
IgnorePaddingMaxPooling2dSize3Test
LayerTestResult< float, 4 > IgnorePaddingMaxPooling2dSize3Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Definition: Pooling2dTestImpl.cpp:1495
armnn::Pooling2dDescriptor::m_OutputShapeRounding
OutputShapeRounding m_OutputShapeRounding
The rounding method for the output shape. (Floor, Ceiling).
Definition: Descriptors.hpp:381
L2Pooling2dSize9Int16Test
LayerTestResult< int16_t, 4 > L2Pooling2dSize9Int16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Definition: Pooling2dTestImpl.cpp:1824
armnn::numeric_cast
std::enable_if_t< std::is_unsigned< Source >::value &&std::is_unsigned< Dest >::value, Dest > numeric_cast(Source source)
Definition: NumericCast.hpp:35
armnnUtils::GetTensorInfo
armnn::TensorInfo GetTensorInfo(unsigned int numberOfBatches, unsigned int numberOfChannels, unsigned int height, unsigned int width, const armnn::DataLayout dataLayout, const armnn::DataType dataType)
Definition: TensorUtils.cpp:38
LargeTensorsAveragePooling2dUint8Test
LayerTestResult< uint8_t, 4 > LargeTensorsAveragePooling2dUint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Definition: Pooling2dTestImpl.cpp:1571
armnn::WorkloadInfo
Contains information about inputs and outputs to a layer.
Definition: WorkloadInfo.hpp:16
Pooling2dTestImpl.hpp
L2Pooling2dSize3Stride3Uint8Test
LayerTestResult< uint8_t, 4 > L2Pooling2dSize3Stride3Uint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Definition: Pooling2dTestImpl.cpp:1735
armnn::TensorInfo::SetQuantizationOffset
void SetQuantizationOffset(int32_t offset)
Definition: Tensor.cpp:480
IgnorePaddingSimpleL2Pooling2dUint8Test
LayerTestResult< uint8_t, 4 > IgnorePaddingSimpleL2Pooling2dUint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Definition: Pooling2dTestImpl.cpp:1841
SimpleAveragePooling2dInt16Test
LayerTestResult< int16_t, 4 > SimpleAveragePooling2dInt16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, const armnn::DataLayout dataLayout)
Definition: Pooling2dTestImpl.cpp:1542
IgnorePaddingSimpleAveragePooling2dTest
LayerTestResult< float, 4 > IgnorePaddingSimpleAveragePooling2dTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Definition: Pooling2dTestImpl.cpp:1588
IgnorePaddingMaxPooling2dSize3Int16Test
LayerTestResult< int16_t, 4 > IgnorePaddingMaxPooling2dSize3Int16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Definition: Pooling2dTestImpl.cpp:1513
IgnorePaddingSimpleAveragePooling2dNoPaddingTest
LayerTestResult< float, 4 > IgnorePaddingSimpleAveragePooling2dNoPaddingTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Definition: Pooling2dTestImpl.cpp:1615
armnn::Pooling2dDescriptor
A Pooling2dDescriptor for the Pooling2dLayer.
Definition: Descriptors.hpp:329
IgnorePaddingSimpleMaxPooling2dTest
LayerTestResult< float, 4 > IgnorePaddingSimpleMaxPooling2dTest(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Definition: Pooling2dTestImpl.cpp:1468
L2Pooling2dSize3Stride1Int16Test
LayerTestResult< int16_t, 4 > L2Pooling2dSize3Stride1Int16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Definition: Pooling2dTestImpl.cpp:1717
IgnorePaddingL2Pooling2dSize3Int16Test
LayerTestResult< int16_t, 4 > IgnorePaddingL2Pooling2dSize3Int16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Definition: Pooling2dTestImpl.cpp:1877
SimpleMaxPooling2dSize3x3Stride2x4Uint8Test
LayerTestResult< uint8_t, 4 > SimpleMaxPooling2dSize3x3Stride2x4Uint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, bool forceNoPadding)
Definition: Pooling2dTestImpl.cpp:1419
IgnorePaddingSimpleL2Pooling2dInt16Test
LayerTestResult< int16_t, 4 > IgnorePaddingSimpleL2Pooling2dInt16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Definition: Pooling2dTestImpl.cpp:1850
SimpleMaxPooling2dSize2x2Stride2x2Int16Test
LayerTestResult< int16_t, 4 > SimpleMaxPooling2dSize2x2Stride2x2Int16Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory, bool forceNoPadding)
Definition: Pooling2dTestImpl.cpp:1399
armnnUtils::DataLayoutIndexed::GetChannelsIndex
unsigned int GetChannelsIndex() const
Definition: DataLayoutIndexed.hpp:23
armnn::ITensorHandleFactory::CreateTensorHandle
virtual std::unique_ptr< ITensorHandle > CreateTensorHandle(const TensorInfo &tensorInfo) const =0
armnn::Pooling2dDescriptor::m_StrideY
uint32_t m_StrideY
Stride value when proceeding through input for the height dimension.
Definition: Descriptors.hpp:379
L2Pooling2dSize7Uint8Test
LayerTestResult< uint8_t, 4 > L2Pooling2dSize7Uint8Test(armnn::IWorkloadFactory &workloadFactory, const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager, const armnn::ITensorHandleFactory &tensorHandleFactory)
Definition: Pooling2dTestImpl.cpp:1788
CopyDataToITensorHandle
void CopyDataToITensorHandle(armnn::ITensorHandle *tensorHandle, const void *memory)
Definition: TensorCopyUtils.cpp:9