src/backends/backendsCommon/test/LayerTests.hpp

   1 //
   2 // Copyright © 2017 Arm Ltd. All rights reserved.
   3 // SPDX-License-Identifier: MIT
   4 //
   5 #pragma once
   6
   7 #include <armnn/ArmNN.hpp>
   8 #include <armnn/Tensor.hpp>
   9
  10 #include <Half.hpp>
  11 #include "TensorCopyUtils.hpp"
  12 #include "WorkloadTestUtils.hpp"
  13 #include "TensorUtils.hpp"
  14 #include "Permute.hpp"
  15
  16 #include <backendsCommon/CpuTensorHandle.hpp>
  17 #include <backendsCommon/IBackendInternal.hpp>
  18 #include <backendsCommon/IMemoryManager.hpp>
  19 #include <reference/workloads/Decoders.hpp>
  20 #include <reference/workloads/Encoders.hpp>
  21 #include <test/TensorHelpers.hpp>
  22
  23 #include <boost/multi_array.hpp>
  24 #include <boost/assert.hpp>
  25
  26 #include <array>
  27
  28 // Layer callables.
  29
  30 namespace armnn
  31 {
  32 class IWorkloadFactory;
  33 }
  34
  35 template <std::size_t n>
  36 boost::array<unsigned int, n> GetTensorShapeAsArray(const armnn::TensorInfo& tensorInfo)
  37 {
  38     BOOST_ASSERT_MSG(n == tensorInfo.GetNumDimensions(),
  39         "Attempting to construct a shape array of mismatching size");
  40
  41     boost::array<unsigned int, n> shape;
  42     for (unsigned int i = 0; i < n; i++)
  43     {
  44         shape[i] = tensorInfo.GetShape()[i];
  45     }
  46     return shape;
  47 }
  48
  49 template <typename T, std::size_t n>
  50 struct LayerTestResult
  51 {
  52     LayerTestResult(const armnn::TensorInfo& outputInfo)
  53     {
  54         auto shape( GetTensorShapeAsArray<n>(outputInfo) );
  55         output.resize(shape);
  56         outputExpected.resize(shape);
  57         supported = true;
  58         compareBoolean = false;
  59     }
  60
  61     boost::multi_array<T, n> output;
  62     boost::multi_array<T, n> outputExpected;
  63     bool supported;
  64     bool compareBoolean;
  65 };
  66
  67 LayerTestResult<float, 4> SimpleConvolution2d3x5Test(
  68     armnn::IWorkloadFactory& workloadFactory,
  69     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
  70     bool biasEnabled,
  71     const armnn::DataLayout layout);
  72
  73 LayerTestResult<float, 4> SimpleConvolution2d3x3Test(
  74     armnn::IWorkloadFactory& workloadFactory,
  75     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
  76     bool biasEnabled,
  77     const armnn::DataLayout layout);
  78
  79 LayerTestResult<float, 4> SimpleConvolution2d3x3Stride2x2Test(
  80     armnn::IWorkloadFactory& workloadFactory,
  81     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
  82     bool biasEnabled,
  83     const armnn::DataLayout layout);
  84
  85 LayerTestResult<float, 4> SimpleConvolution2d3x3NhwcTest(
  86     armnn::IWorkloadFactory& workloadFactory,
  87     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
  88     bool biasEnabled);
  89
  90 LayerTestResult<float, 4> Convolution2dAsymmetricPaddingLargerThanHalfKernelSizeTest(
  91     armnn::IWorkloadFactory& workloadFactory,
  92     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
  93     armnn::DataLayout layout);
  94
  95 LayerTestResult<float, 4> Convolution2dAsymmetricPaddingTest(
  96     armnn::IWorkloadFactory& workloadFactory,
  97     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
  98     armnn::DataLayout layout);
  99
 100 LayerTestResult<float,   4> Convolution1dTest(
 101     armnn::IWorkloadFactory& workloadFactory,
 102     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 103     bool biasEnabled);
 104
 105 LayerTestResult<uint8_t, 4> Convolution1dUint8Test(
 106     armnn::IWorkloadFactory& workloadFactory,
 107     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 108     bool biasEnabled);
 109
 110 LayerTestResult<float, 4> DepthwiseConvolution2dTest(
 111     armnn::IWorkloadFactory& workloadFactory,
 112     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 113     bool biasEnabled,
 114     const armnn::DataLayout layout);
 115
 116 template<armnn::DataType ArmnnType, armnn::DataType ArmnnBType, typename T = armnn::ResolveType<ArmnnType>>
 117 LayerTestResult<T, 4> Convolution2d3x3Dilation3x3Test(
 118     armnn::IWorkloadFactory& workloadFactory,
 119     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 120     bool biasEnabled,
 121     const armnn::DataLayout layout);
 122
 123 template<armnn::DataType ArmnnType, armnn::DataType ArmnnBType, typename T = armnn::ResolveType<ArmnnType>>
 124 LayerTestResult<T, 4> Convolution2d2x3x3Dilation3x3Test(
 125     armnn::IWorkloadFactory& workloadFactory,
 126     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 127     bool biasEnabled,
 128     const armnn::DataLayout layout);
 129
 130 template<armnn::DataType ArmnnType, armnn::DataType ArmnnBType, typename T = armnn::ResolveType<ArmnnType>>
 131 LayerTestResult<T, 4> Convolution2d2x2Dilation2x2Padding2x2Stride3x3Test(
 132     armnn::IWorkloadFactory &workloadFactory,
 133     const armnn::IBackendInternal::IMemoryManagerSharedPtr &memoryManager,
 134     bool biasEnabled,
 135     const armnn::DataLayout layout);
 136
 137 template<armnn::DataType ArmnnType, armnn::DataType ArmnnBType, typename T = armnn::ResolveType<ArmnnType>>
 138 LayerTestResult<T, 4> DepthwiseConvolution2d3x3Dilation3x3Test(
 139     armnn::IWorkloadFactory& workloadFactory,
 140     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 141     bool biasEnabled,
 142     const armnn::DataLayout layout);
 143
 144 template<armnn::DataType ArmnnType, armnn::DataType ArmnnBType, typename T = armnn::ResolveType<ArmnnType>>
 145 LayerTestResult<T, 4> DepthwiseConvolution2d2x3x3Dilation3x3Test(
 146     armnn::IWorkloadFactory& workloadFactory,
 147     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 148     bool biasEnabled,
 149     const armnn::DataLayout layout);
 150
 151 LayerTestResult<float, 4> DepthwiseConvolution2dDepthNhwcTest(
 152     armnn::IWorkloadFactory& workloadFactory,
 153     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 154     bool biasEnabled);
 155
 156 LayerTestResult<float, 4> DepthwiseConvolution2dDepthMul1Test(
 157     armnn::IWorkloadFactory& workloadFactory,
 158     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 159     bool biasEnabled,
 160     const armnn::DataLayout layout);
 161
 162 LayerTestResult<float, 4> DepthwiseConvolution2dAsymmetricTest(
 163     armnn::IWorkloadFactory& workloadFactory,
 164     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 165     bool biasEnabled,
 166     const armnn::DataLayout layout);
 167
 168 LayerTestResult<float, 4> SimpleDepthwiseConvolution2d3x3Dilation3x3NhwcTest(
 169     armnn::IWorkloadFactory& workloadFactory,
 170     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 171
 172 LayerTestResult<float, 4> CompareDepthwiseConvolution2dFloatTest(
 173     armnn::IWorkloadFactory& workloadFactory,
 174     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 175     armnn::IWorkloadFactory& refWorkloadFactory,
 176     const armnn::DataLayout layout);
 177
 178 LayerTestResult<uint8_t, 4> CompareDepthwiseConvolution2dUint8Test(
 179     armnn::IWorkloadFactory& workloadFactory,
 180     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 181     armnn::IWorkloadFactory& refWorkloadFactory,
 182     const armnn::DataLayout layout);
 183
 184 LayerTestResult<float,   4> SimpleMaxPooling2dSize2x2Stride2x2Test(
 185     armnn::IWorkloadFactory& workloadFactory,
 186     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 187     bool forceNoPadding);
 188
 189 LayerTestResult<uint8_t, 4> SimpleMaxPooling2dSize2x2Stride2x2Uint8Test(
 190     armnn::IWorkloadFactory& workloadFactory,
 191     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 192     bool forceNoPadding);
 193
 194 LayerTestResult<int16_t, 4> SimpleMaxPooling2dSize2x2Stride2x2Int16Test(
 195     armnn::IWorkloadFactory& workloadFactory,
 196     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 197     bool forceNoPadding);
 198
 199 LayerTestResult<float,   4> SimpleMaxPooling2dSize3x3Stride2x4Test(
 200     armnn::IWorkloadFactory& workloadFactory,
 201     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 202     bool forceNoPadding);
 203
 204 LayerTestResult<uint8_t, 4> SimpleMaxPooling2dSize3x3Stride2x4Uint8Test(
 205     armnn::IWorkloadFactory& workloadFactory,
 206     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 207     bool forceNoPadding );
 208
 209 LayerTestResult<int16_t, 4> SimpleMaxPooling2dSize3x3Stride2x4Int16Test(
 210     armnn::IWorkloadFactory& workloadFactory,
 211     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 212     bool forceNoPadding );
 213
 214 LayerTestResult<float,   4> SimpleMaxPooling2dTest(
 215     armnn::IWorkloadFactory& workloadFactory,
 216     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 217     const armnn::DataLayout dataLayout);
 218
 219 LayerTestResult<uint8_t, 4> SimpleMaxPooling2dUint8Test(
 220     armnn::IWorkloadFactory& workloadFactory,
 221     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 222     const armnn::DataLayout dataLayout);
 223
 224 LayerTestResult<int16_t, 4> SimpleMaxPooling2dInt16Test(
 225     armnn::IWorkloadFactory& workloadFactory,
 226     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 227     const armnn::DataLayout dataLayout);
 228
 229 LayerTestResult<float,   4> IgnorePaddingSimpleMaxPooling2dTest(
 230     armnn::IWorkloadFactory& workloadFactory,
 231     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 232
 233 LayerTestResult<uint8_t, 4> IgnorePaddingSimpleMaxPooling2dUint8Test(
 234     armnn::IWorkloadFactory& workloadFactory,
 235     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 236
 237 LayerTestResult<int16_t, 4> IgnorePaddingSimpleMaxPooling2dInt16Test(
 238     armnn::IWorkloadFactory& workloadFactory,
 239     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 240
 241 LayerTestResult<float,   4> IgnorePaddingMaxPooling2dSize3Test(
 242     armnn::IWorkloadFactory& workloadFactory,
 243     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 244
 245 LayerTestResult<uint8_t, 4> IgnorePaddingMaxPooling2dSize3Uint8Test(
 246     armnn::IWorkloadFactory& workloadFactory,
 247     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 248
 249 LayerTestResult<int16_t, 4> IgnorePaddingMaxPooling2dSize3Int16Test(
 250     armnn::IWorkloadFactory& workloadFactory,
 251     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 252
 253 LayerTestResult<float,   4> SimpleAveragePooling2dTest(
 254     armnn::IWorkloadFactory& workloadFactory,
 255     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 256     const armnn::DataLayout dataLayout);
 257
 258 LayerTestResult<uint8_t, 4> SimpleAveragePooling2dUint8Test(
 259     armnn::IWorkloadFactory& workloadFactory,
 260     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 261     const armnn::DataLayout dataLayout);
 262
 263 LayerTestResult<int16_t, 4> SimpleAveragePooling2dInt16Test(
 264     armnn::IWorkloadFactory& workloadFactory,
 265     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 266     const armnn::DataLayout dataLayout);
 267
 268 LayerTestResult<float,   4> LargeTensorsAveragePooling2dTest(
 269     armnn::IWorkloadFactory& workloadFactory,
 270     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 271
 272 LayerTestResult<uint8_t, 4> LargeTensorsAveragePooling2dUint8Test(
 273     armnn::IWorkloadFactory& workloadFactory,
 274     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 275
 276 LayerTestResult<int16_t, 4> LargeTensorsAveragePooling2dInt16Test(
 277     armnn::IWorkloadFactory& workloadFactory,
 278     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 279
 280 LayerTestResult<float,   4> IgnorePaddingAveragePooling2dSize3x2Stride2x2Test(
 281     armnn::IWorkloadFactory& workloadFactory,
 282     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 283     bool forceNoPadding);
 284
 285 LayerTestResult<float,   4> IgnorePaddingSimpleAveragePooling2dTest(
 286     armnn::IWorkloadFactory& workloadFactory,
 287     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 288
 289 LayerTestResult<uint8_t, 4> IgnorePaddingSimpleAveragePooling2dUint8Test(
 290     armnn::IWorkloadFactory& workloadFactory,
 291     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 292
 293 LayerTestResult<int16_t, 4> IgnorePaddingSimpleAveragePooling2dInt16Test(
 294     armnn::IWorkloadFactory& workloadFactory,
 295     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 296
 297 LayerTestResult<float, 4>   IgnorePaddingSimpleAveragePooling2dNoPaddingTest(
 298     armnn::IWorkloadFactory& workloadFactory,
 299     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 300
 301 LayerTestResult<uint8_t, 4> IgnorePaddingSimpleAveragePooling2dNoPaddingUint8Test(
 302     armnn::IWorkloadFactory& workloadFactory,
 303     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 304
 305 LayerTestResult<int16_t, 4> IgnorePaddingSimpleAveragePooling2dNoPaddingInt16Test(
 306     armnn::IWorkloadFactory& workloadFactory,
 307     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 308
 309 LayerTestResult<float,   4> IgnorePaddingAveragePooling2dSize3Test(
 310     armnn::IWorkloadFactory& workloadFactory,
 311     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 312
 313 LayerTestResult<uint8_t, 4> IgnorePaddingAveragePooling2dSize3Uint8Test(
 314     armnn::IWorkloadFactory& workloadFactory,
 315     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 316
 317 LayerTestResult<int16_t, 4> IgnorePaddingAveragePooling2dSize3Int16Test(
 318         armnn::IWorkloadFactory& workloadFactory,
 319         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 320
 321 LayerTestResult<float,   4> SimpleL2Pooling2dTest(
 322     armnn::IWorkloadFactory& workloadFactory,
 323     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 324     const armnn::DataLayout dataLayout);
 325
 326 LayerTestResult<uint8_t, 4> SimpleL2Pooling2dUint8Test(
 327     armnn::IWorkloadFactory& workloadFactory,
 328     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 329     const armnn::DataLayout dataLayout);
 330
 331 LayerTestResult<int16_t, 4> SimpleL2Pooling2dInt16Test(
 332     armnn::IWorkloadFactory& workloadFactory,
 333     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 334     const armnn::DataLayout dataLayout);
 335
 336 LayerTestResult<float,   4> L2Pooling2dSize3Stride1Test(
 337     armnn::IWorkloadFactory& workloadFactory,
 338     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 339
 340 LayerTestResult<uint8_t, 4> L2Pooling2dSize3Stride1Uint8Test(
 341     armnn::IWorkloadFactory& workloadFactory,
 342     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 343
 344 LayerTestResult<int16_t, 4> L2Pooling2dSize3Stride1Int16Test(
 345     armnn::IWorkloadFactory& workloadFactory,
 346     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 347
 348 LayerTestResult<float,   4> L2Pooling2dSize3Stride3Test(
 349     armnn::IWorkloadFactory& workloadFactory,
 350     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 351
 352 LayerTestResult<uint8_t, 4> L2Pooling2dSize3Stride3Uint8Test(
 353     armnn::IWorkloadFactory& workloadFactory,
 354     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 355
 356 LayerTestResult<int16_t, 4> L2Pooling2dSize3Stride3Int16Test(
 357     armnn::IWorkloadFactory& workloadFactory,
 358     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 359
 360 LayerTestResult<float,   4> L2Pooling2dSize3Stride4Test(
 361     armnn::IWorkloadFactory& workloadFactory,
 362     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 363
 364 LayerTestResult<uint8_t, 4> L2Pooling2dSize3Stride4Uint8Test(
 365     armnn::IWorkloadFactory& workloadFactory,
 366     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 367
 368 LayerTestResult<int16_t, 4> L2Pooling2dSize3Stride4Int16Test(
 369     armnn::IWorkloadFactory& workloadFactory,
 370     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 371
 372 LayerTestResult<float,   4> L2Pooling2dSize7Test(
 373     armnn::IWorkloadFactory& workloadFactory,
 374     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 375
 376 LayerTestResult<uint8_t, 4> L2Pooling2dSize7Uint8Test(
 377     armnn::IWorkloadFactory& workloadFactory,
 378     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 379
 380 LayerTestResult<int16_t, 4> L2Pooling2dSize7Int16Test(
 381     armnn::IWorkloadFactory& workloadFactory,
 382     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 383
 384 LayerTestResult<float,   4> L2Pooling2dSize9Test(
 385     armnn::IWorkloadFactory& workloadFactory,
 386     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 387
 388 LayerTestResult<uint8_t, 4> L2Pooling2dSize9Uint8Test(
 389     armnn::IWorkloadFactory& workloadFactory,
 390     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 391
 392 LayerTestResult<int16_t, 4> L2Pooling2dSize9Int16Test(
 393     armnn::IWorkloadFactory& workloadFactory,
 394     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 395
 396 LayerTestResult<float,   4> IgnorePaddingSimpleL2Pooling2dTest(
 397     armnn::IWorkloadFactory& workloadFactory,
 398     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 399
 400 LayerTestResult<uint8_t, 4> IgnorePaddingSimpleL2Pooling2dUint8Test(
 401     armnn::IWorkloadFactory& workloadFactory,
 402     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 403
 404 LayerTestResult<int16_t, 4> IgnorePaddingSimpleL2Pooling2dInt16Test(
 405     armnn::IWorkloadFactory& workloadFactory,
 406     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 407
 408 LayerTestResult<float,   4> IgnorePaddingL2Pooling2dSize3Test(
 409     armnn::IWorkloadFactory& workloadFactory,
 410     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 411
 412 LayerTestResult<uint8_t, 4> IgnorePaddingL2Pooling2dSize3Uint8Test(
 413     armnn::IWorkloadFactory& workloadFactory,
 414     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 415
 416 LayerTestResult<int16_t, 4> IgnorePaddingL2Pooling2dSize3Int16Test(
 417     armnn::IWorkloadFactory& workloadFactory,
 418     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 419
 420 LayerTestResult<float,   4> AsymmetricNonSquarePooling2dTest(
 421     armnn::IWorkloadFactory& workloadFactory,
 422     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 423
 424 LayerTestResult<uint8_t, 4> AsymmetricNonSquarePooling2dUint8Test(
 425     armnn::IWorkloadFactory& workloadFactory,
 426     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 427
 428 LayerTestResult<int16_t, 4> AsymmetricNonSquarePooling2dInt16Test(
 429     armnn::IWorkloadFactory& workloadFactory,
 430     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 431
 432 LayerTestResult<float, 4> ComparePooling2dTest(
 433     armnn::IWorkloadFactory& workloadFactory,
 434     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 435     armnn::IWorkloadFactory& refWorkloadFactory,
 436     armnn::PoolingAlgorithm  poolingType);
 437
 438 LayerTestResult<uint8_t, 4> ComparePooling2dUint8Test(
 439     armnn::IWorkloadFactory& workloadFactory,
 440     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 441     armnn::IWorkloadFactory& refWorkloadFactory,
 442     armnn::PoolingAlgorithm  poolingType);
 443
 444 LayerTestResult<int16_t, 4> ComparePooling2dInt16Test(
 445     armnn::IWorkloadFactory& workloadFactory,
 446     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 447     armnn::IWorkloadFactory& refWorkloadFactory,
 448     armnn::PoolingAlgorithm  poolingType);
 449
 450 LayerTestResult<float, 4> ConstantLinearActivationTest(
 451     armnn::IWorkloadFactory& workloadFactory,
 452     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 453
 454 LayerTestResult<float, 4> SimpleNormalizationAcrossTest(
 455     armnn::IWorkloadFactory& workloadFactory,
 456     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 457
 458 LayerTestResult<float, 4> SimpleNormalizationWithinTest(
 459     armnn::IWorkloadFactory& workloadFactory,
 460     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 461
 462 LayerTestResult<float,4> SimpleNormalizationAcrossNhwcTest(
 463     armnn::IWorkloadFactory& workloadFactory,
 464     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 465
 466 LayerTestResult<float, 2> SimpleSoftmaxTest(
 467     armnn::IWorkloadFactory& workloadFactory,
 468     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 469     float beta);
 470
 471 LayerTestResult<float, 3> Simple3dSoftmaxTest(
 472         armnn::IWorkloadFactory& workloadFactory,
 473         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 474         float beta);
 475
 476 LayerTestResult<float, 4> Simple4dSoftmaxTest(
 477         armnn::IWorkloadFactory& workloadFactory,
 478         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 479         float beta);
 480
 481 LayerTestResult<uint8_t, 2> SimpleSoftmaxUint8Test(
 482     armnn::IWorkloadFactory& workloadFactory,
 483     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 484     float beta);
 485
 486 LayerTestResult<uint8_t,3> Simple3dSoftmaxUint8Test(
 487         armnn::IWorkloadFactory& workloadFactory,
 488         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 489         float beta);
 490
 491 LayerTestResult<uint8_t,4> Simple4dSoftmaxUint8Test(
 492         armnn::IWorkloadFactory& workloadFactory,
 493         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 494         float beta);
 495
 496 LayerTestResult<int16_t,2> SimpleSoftmaxUint16Test(
 497         armnn::IWorkloadFactory& workloadFactory,
 498         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 499         float beta);
 500
 501 LayerTestResult<int16_t,3> Simple3dSoftmaxUint16Test(
 502         armnn::IWorkloadFactory& workloadFactory,
 503         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 504         float beta);
 505
 506 LayerTestResult<int16_t,4> Simple4dSoftmaxUint16Test(
 507         armnn::IWorkloadFactory& workloadFactory,
 508         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 509         float beta);
 510
 511 LayerTestResult<float, 4> SimpleSigmoidTest(
 512     armnn::IWorkloadFactory& workloadFactory,
 513     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 514
 515 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 516 LayerTestResult<T, 4> SimpleReshapeTest(
 517     armnn::IWorkloadFactory& workloadFactory,
 518     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 519
 520 LayerTestResult<float, 4> SimpleFloorTest(
 521     armnn::IWorkloadFactory& workloadFactory,
 522     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 523
 524 LayerTestResult<float, 1> Concatenation1dTest(
 525     armnn::IWorkloadFactory& workloadFactory,
 526     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 527
 528 LayerTestResult<float, 2> Concatenation2dDim0Test(
 529     armnn::IWorkloadFactory& workloadFactory,
 530     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 531
 532 LayerTestResult<float, 2> Concatenation2dDim1Test(
 533     armnn::IWorkloadFactory& workloadFactory,
 534     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 535
 536 LayerTestResult<float, 2> Concatenation2dDim0DiffInputDimsTest(
 537     armnn::IWorkloadFactory& workloadFactory,
 538     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 539
 540 LayerTestResult<float, 2> Concatenation2dDim1DiffInputDimsTest(
 541     armnn::IWorkloadFactory& workloadFactory,
 542     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 543
 544 LayerTestResult<float, 3> Concatenation3dDim0Test(
 545     armnn::IWorkloadFactory& workloadFactory,
 546     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 547
 548 LayerTestResult<float, 3> Concatenation3dDim1Test(
 549     armnn::IWorkloadFactory& workloadFactory,
 550     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 551
 552 LayerTestResult<float, 3> Concatenation3dDim2Test(
 553     armnn::IWorkloadFactory& workloadFactory,
 554     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 555     bool useSubtensor);
 556
 557 LayerTestResult<float, 3> Concatenation3dDim0DiffInputDimsTest(
 558     armnn::IWorkloadFactory& workloadFactory,
 559     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 560
 561 LayerTestResult<float, 3> Concatenation3dDim1DiffInputDimsTest(
 562     armnn::IWorkloadFactory& workloadFactory,
 563     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 564
 565 LayerTestResult<float, 3> Concatenation3dDim2DiffInputDimsTest(
 566     armnn::IWorkloadFactory& workloadFactory,
 567     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 568     bool useSubtensor);
 569
 570 LayerTestResult<float, 4> Concatenation4dDim0Test(
 571     armnn::IWorkloadFactory& workloadFactory,
 572     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 573
 574 LayerTestResult<float, 4> Concatenation4dDim1Test(
 575     armnn::IWorkloadFactory& workloadFactory,
 576     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 577
 578 LayerTestResult<float, 4> Concatenation4dDim2Test(
 579     armnn::IWorkloadFactory& workloadFactory,
 580     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 581
 582 LayerTestResult<float, 4> Concatenation4dDim3Test(
 583     armnn::IWorkloadFactory& workloadFactory,
 584     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 585     bool useSubtensor);
 586
 587 LayerTestResult<float, 4> Concatenation4dDiffShapeDim0Test(
 588     armnn::IWorkloadFactory& workloadFactory,
 589     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 590
 591 LayerTestResult<float, 4> Concatenation4dDiffShapeDim1Test(
 592     armnn::IWorkloadFactory& workloadFactory,
 593     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 594
 595 LayerTestResult<float, 4> Concatenation4dDiffShapeDim2Test(
 596     armnn::IWorkloadFactory& workloadFactory,
 597     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 598
 599 LayerTestResult<float, 4> Concatenation4dDiffShapeDim3Test(
 600     armnn::IWorkloadFactory& workloadFactory,
 601     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 602     bool useSubtensor);
 603
 604 LayerTestResult<uint8_t, 4> Concatenation4dDim0Uint8Test(
 605     armnn::IWorkloadFactory& workloadFactory,
 606     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 607
 608 LayerTestResult<uint8_t, 4> Concatenation4dDim1Uint8Test(
 609     armnn::IWorkloadFactory& workloadFactory,
 610     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 611
 612 LayerTestResult<uint8_t, 4> Concatenation4dDim2Uint8Test(
 613     armnn::IWorkloadFactory& workloadFactory,
 614     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 615
 616 LayerTestResult<uint8_t, 4> Concatenation4dDim3Uint8Test(
 617     armnn::IWorkloadFactory& workloadFactory,
 618     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 619     bool useSubtensor);
 620
 621 LayerTestResult<uint8_t, 4> Concatenation4dDiffShapeDim0Uint8Test(
 622     armnn::IWorkloadFactory& workloadFactory,
 623     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 624
 625 LayerTestResult<uint8_t, 4> Concatenation4dDiffShapeDim1Uint8Test(
 626     armnn::IWorkloadFactory& workloadFactory,
 627     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 628
 629 LayerTestResult<uint8_t, 4> Concatenation4dDiffShapeDim2Uint8Test(
 630     armnn::IWorkloadFactory& workloadFactory,
 631     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 632
 633 LayerTestResult<uint8_t, 4> Concatenation4dDiffShapeDim3Uint8Test(
 634     armnn::IWorkloadFactory& workloadFactory,
 635     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 636     bool useSubtensor);
 637
 638 LayerTestResult<uint8_t, 4> SimpleSigmoidUint8Test(
 639     armnn::IWorkloadFactory& workloadFactory,
 640     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 641
 642 LayerTestResult<int16_t, 4> SimpleSigmoidInt16Test(
 643         armnn::IWorkloadFactory& workloadFactory,
 644         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 645
 646 LayerTestResult<float, 4> CompareConvolution2dTest(
 647     armnn::IWorkloadFactory& workloadFactory,
 648     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 649     armnn::IWorkloadFactory& refWorkloadFactory);
 650
 651 template<typename T>
 652 LayerTestResult<T, 4> CompareDepthwiseConvolution2dTest(
 653     armnn::IWorkloadFactory& workloadFactory,
 654     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 655     armnn::IWorkloadFactory& refWorkloadFactory,
 656     const armnn::DataLayout layout);
 657
 658 LayerTestResult<float, 4> CompareNormalizationTest(
 659     armnn::IWorkloadFactory& workloadFactory,
 660     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 661     armnn::IWorkloadFactory& refWorkloadFactory,
 662     armnn::NormalizationAlgorithmChannel normChannel,
 663     armnn::NormalizationAlgorithmMethod normMethod);
 664
 665 LayerTestResult<float, 2> CompareSoftmaxTest(
 666     armnn::IWorkloadFactory& workloadFactory,
 667     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 668     armnn::IWorkloadFactory& refWorkloadFactory,
 669     float beta);
 670
 671 LayerTestResult<float, 2> FullyConnectedFloat32Test(
 672     armnn::IWorkloadFactory& workloadFactory,
 673     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 674     bool biasEnabled,
 675     bool transposeWeights);
 676
 677 std::vector<LayerTestResult<float, 3>> SplitterTest(
 678     armnn::IWorkloadFactory& workloadFactory,
 679     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 680
 681 LayerTestResult<float, 3> CopyViaSplitterTest(
 682     armnn::IWorkloadFactory& workloadFactory,
 683     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 684
 685 LayerTestResult<float, 3> ConcatTest(
 686     armnn::IWorkloadFactory& workloadFactory,
 687     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 688
 689 LayerTestResult<float, 4> AdditionTest(
 690     armnn::IWorkloadFactory& workloadFactory,
 691     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 692
 693 LayerTestResult<float, 4> AdditionBroadcast1ElementTest(
 694     armnn::IWorkloadFactory& workloadFactory,
 695     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 696
 697 LayerTestResult<float, 4> AdditionBroadcastTest(
 698     armnn::IWorkloadFactory& workloadFactory,
 699     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 700
 701 LayerTestResult<float, 4> CompareAdditionTest(
 702     armnn::IWorkloadFactory& workloadFactory,
 703     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 704     armnn::IWorkloadFactory& refWorkloadFactory);
 705
 706 LayerTestResult<float, 4> SubtractionTest(
 707     armnn::IWorkloadFactory& workloadFactory,
 708     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 709
 710 LayerTestResult<float, 4> SubtractionBroadcast1ElementTest(
 711     armnn::IWorkloadFactory& workloadFactory,
 712     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 713
 714 LayerTestResult<float, 4> SubtractionBroadcastTest(
 715     armnn::IWorkloadFactory& workloadFactory,
 716     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 717
 718 LayerTestResult<float, 4> CompareActivationTest(
 719     armnn::IWorkloadFactory& workloadFactory,
 720     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 721     armnn::IWorkloadFactory& refWorkloadFactory,
 722     armnn::ActivationFunction f,
 723     unsigned int batchSize);
 724
 725 LayerTestResult<float, 4> DivisionTest(
 726     armnn::IWorkloadFactory& workloadFactory,
 727     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 728
 729 LayerTestResult<float, 4> DivisionByZeroTest(
 730     armnn::IWorkloadFactory& workloadFactory,
 731     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 732
 733 LayerTestResult<float, 4> DivisionBroadcast1ElementTest(
 734     armnn::IWorkloadFactory& workloadFactory,
 735     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 736
 737 LayerTestResult<float, 4> DivisionBroadcast1DVectorTest(
 738     armnn::IWorkloadFactory& workloadFactory,
 739     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 740
 741 LayerTestResult<float, 4> MultiplicationTest(
 742     armnn::IWorkloadFactory& workloadFactory,
 743     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 744
 745 LayerTestResult<float, 4> MultiplicationBroadcast1ElementTest(
 746     armnn::IWorkloadFactory& workloadFactory,
 747     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 748
 749 LayerTestResult<float, 4> MultiplicationBroadcast1DVectorTest(
 750     armnn::IWorkloadFactory& workloadFactory,
 751     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 752
 753 LayerTestResult<float, 4> CompareMultiplicationTest(
 754     armnn::IWorkloadFactory& workloadFactory,
 755     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 756     armnn::IWorkloadFactory& refWorkloadFactory);
 757
 758 LayerTestResult<float, 4> BatchNormTest(
 759     armnn::IWorkloadFactory& workloadFactory,
 760     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 761
 762 LayerTestResult<float, 4> BatchNormNhwcTest(
 763     armnn::IWorkloadFactory& workloadFactory,
 764     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 765
 766 LayerTestResult<float, 4> CompareBatchNormTest(
 767     armnn::IWorkloadFactory& workloadFactory,
 768     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 769     armnn::IWorkloadFactory& refWorkloadFactory);
 770
 771 LayerTestResult<float, 4> BoundedReLuUpperAndLowerBoundTest(
 772     armnn::IWorkloadFactory& workloadFactory,
 773     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 774
 775 LayerTestResult<uint8_t, 4> BoundedReLuUint8UpperAndLowerBoundTest(
 776     armnn::IWorkloadFactory& workloadFactor,
 777     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManagery);
 778
 779 LayerTestResult<float, 4> BoundedReLuUpperBoundOnlyTest(
 780     armnn::IWorkloadFactory& workloadFactory,
 781     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 782
 783 LayerTestResult<uint8_t, 4> BoundedReLuUint8UpperBoundOnlyTest(
 784     armnn::IWorkloadFactory& workloadFactory,
 785     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 786
 787 LayerTestResult<float, 4> CompareBoundedReLuTest(
 788     armnn::IWorkloadFactory& workloadFactory,
 789     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 790     armnn::IWorkloadFactory& refWorkloadFactory,
 791     float upperBound,
 792     float lowerBound);
 793
 794 LayerTestResult<float, 4> ReLuTest(
 795         armnn::IWorkloadFactory& workloadFactory,
 796         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 797
 798 LayerTestResult<uint8_t, 4> ReLuUint8Test(
 799         armnn::IWorkloadFactory& workloadFactory,
 800         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 801
 802 LayerTestResult<int16_t, 4> ReLuInt16Test(
 803         armnn::IWorkloadFactory& workloadFactory,
 804         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 805
 806 LayerTestResult<int16_t, 4> BoundedReLuInt16Test(
 807         armnn::IWorkloadFactory& workloadFactory,
 808         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 809
 810 LayerTestResult<float, 4> SoftReLuTest(
 811         armnn::IWorkloadFactory& workloadFactory,
 812         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 813
 814 LayerTestResult<uint8_t, 4> SoftReLuUint8Test(
 815         armnn::IWorkloadFactory& workloadFactory,
 816         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 817
 818 LayerTestResult<int16_t, 4> SoftReLuInt16Test(
 819         armnn::IWorkloadFactory& workloadFactory,
 820         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 821
 822 LayerTestResult<float, 4> LeakyReLuTest(
 823         armnn::IWorkloadFactory& workloadFactory,
 824         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 825
 826 LayerTestResult<uint8_t, 4> LeakyReLuUint8Test(
 827         armnn::IWorkloadFactory& workloadFactory,
 828         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 829
 830 LayerTestResult<int16_t, 4> LeakyReLuInt16Test(
 831         armnn::IWorkloadFactory& workloadFactory,
 832         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 833
 834 LayerTestResult<float, 4> AbsTest(
 835         armnn::IWorkloadFactory& workloadFactory,
 836         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 837
 838 LayerTestResult<uint8_t, 4> AbsUint8Test(
 839         armnn::IWorkloadFactory& workloadFactory,
 840         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 841
 842 LayerTestResult<int16_t, 4> AbsInt16Test(
 843         armnn::IWorkloadFactory& workloadFactory,
 844         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 845
 846 LayerTestResult<float, 4> SqrtTest(
 847         armnn::IWorkloadFactory& workloadFactory,
 848         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 849
 850 LayerTestResult<uint8_t, 4> SqrtUint8Test(
 851         armnn::IWorkloadFactory& workloadFactory,
 852         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 853
 854 LayerTestResult<int16_t, 4> SqrtInt16Test(
 855         armnn::IWorkloadFactory& workloadFactory,
 856         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 857
 858 LayerTestResult<float, 4> SquareTest(
 859         armnn::IWorkloadFactory& workloadFactory,
 860         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 861
 862 LayerTestResult<uint8_t, 4> SquareUint8Test(
 863         armnn::IWorkloadFactory& workloadFactory,
 864         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 865
 866 LayerTestResult<int16_t, 4> SquareInt16Test(
 867         armnn::IWorkloadFactory& workloadFactory,
 868         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 869
 870 LayerTestResult<float, 4> TanhTest(
 871         armnn::IWorkloadFactory& workloadFactory,
 872         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 873
 874 LayerTestResult<uint8_t, 4> TanhUint8Test(
 875         armnn::IWorkloadFactory& workloadFactory,
 876         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 877
 878 LayerTestResult<int16_t, 4> TanhInt16Test(
 879         armnn::IWorkloadFactory& workloadFactory,
 880         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 881
 882
 883 // Tests that the output should be identical to the input when the output dimensions match the input ones.
 884 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 885 LayerTestResult<T, 4> ResizeBilinearNopTest(
 886         armnn::IWorkloadFactory& workloadFactory,
 887         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 888         const armnn::DataLayout dataLayout);
 889
 890 // Tests the behaviour of the resize bilinear operation when rescaling a 2x2 image into a 1x1 image.
 891 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 892 LayerTestResult<T, 4> SimpleResizeBilinearTest(
 893         armnn::IWorkloadFactory& workloadFactory,
 894         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 895         const armnn::DataLayout dataLayout);
 896
 897 // Tests the resize bilinear for minification of a square input matrix (also: input dimensions are a
 898 // multiple of output dimensions).
 899 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 900 LayerTestResult<T, 4> ResizeBilinearSqMinTest(
 901         armnn::IWorkloadFactory& workloadFactory,
 902         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 903         const armnn::DataLayout dataLayout);
 904
 905 // Tests the resize bilinear for minification (output dimensions smaller than input dimensions).
 906 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 907 LayerTestResult<T, 4> ResizeBilinearMinTest(
 908         armnn::IWorkloadFactory& workloadFactory,
 909         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 910         const armnn::DataLayout dataLayout);
 911
 912 // Tests the resize bilinear for magnification (output dimensions bigger than input dimensions).
 913 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 914 LayerTestResult<T, 4> ResizeBilinearMagTest(
 915         armnn::IWorkloadFactory& workloadFactory,
 916         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 917         const armnn::DataLayout  dataLayout);
 918
 919 // Tests that the output should be identical to the input when the output dimensions match the input ones.
 920 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 921 LayerTestResult<T, 4> ResizeNearestNeighborNopTest(
 922         armnn::IWorkloadFactory& workloadFactory,
 923         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 924         const armnn::DataLayout dataLayout);
 925
 926 // Tests the behaviour of the resize NearestNeighbor operation when rescaling a 2x2 image into a 1x1 image.
 927 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 928 LayerTestResult<T, 4> SimpleResizeNearestNeighborTest(
 929         armnn::IWorkloadFactory& workloadFactory,
 930         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 931         const armnn::DataLayout dataLayout);
 932
 933 // Tests the resize NearestNeighbor for minification of a square input matrix (also: input dimensions are a
 934 // multiple of output dimensions).
 935 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 936 LayerTestResult<T, 4> ResizeNearestNeighborSqMinTest(
 937         armnn::IWorkloadFactory& workloadFactory,
 938         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 939         const armnn::DataLayout dataLayout);
 940
 941 // Tests the resize NearestNeighbor for minification (output dimensions smaller than input dimensions).
 942 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 943 LayerTestResult<T, 4> ResizeNearestNeighborMinTest(
 944         armnn::IWorkloadFactory& workloadFactory,
 945         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 946         const armnn::DataLayout dataLayout);
 947
 948 // Tests the resize NearestNeighbor for magnification (output dimensions bigger than input dimensions).
 949 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 950 LayerTestResult<T, 4> ResizeNearestNeighborMagTest(
 951         armnn::IWorkloadFactory& workloadFactory,
 952         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 953         const armnn::DataLayout  dataLayout,
 954         float inQuantScale,
 955         int32_t inQuantOffset,
 956         float outQuantScale,
 957         int32_t outQuantOffset);
 958
 959 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 960 LayerTestResult<T, 2> Rsqrt2dTestCommon(
 961         armnn::IWorkloadFactory& workloadFactory,
 962         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
 963         const armnn::TensorInfo inputTensorInfo,
 964         const armnn::TensorInfo outputTensorInfo,
 965         const std::vector<float>& inputValues,
 966         const std::vector<float>& expectedOutputValues);
 967
 968 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 969 LayerTestResult<T, 2> Rsqrt2dTest(
 970     armnn::IWorkloadFactory& workloadFactory,
 971     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 972
 973 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 974 LayerTestResult<T, 3> Rsqrt3dTest(
 975     armnn::IWorkloadFactory& workloadFactory,
 976     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 977
 978 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 979 LayerTestResult<T, 2> RsqrtZeroTest(
 980     armnn::IWorkloadFactory& workloadFactory,
 981     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 982
 983 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
 984 LayerTestResult<T, 2> RsqrtNegativeTest(
 985     armnn::IWorkloadFactory& workloadFactory,
 986     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 987
 988 LayerTestResult<float, 4> BatchNormTest(
 989     armnn::IWorkloadFactory& workloadFactory,
 990     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 991
 992 LayerTestResult<float, 4> BatchNormNhwcTest(
 993     armnn::IWorkloadFactory& workloadFactory,
 994     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 995
 996 LayerTestResult<float, 2> FakeQuantizationTest(
 997     armnn::IWorkloadFactory& workloadFactory,
 998     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
 999
1000 LayerTestResult<float, 4> L2NormalizationDefaultEpsilonTest(
1001         armnn::IWorkloadFactory& workloadFactory,
1002         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1003         const armnn::DataLayout layout);
1004
1005 LayerTestResult<float, 4> L2NormalizationNonDefaultEpsilonTest(
1006         armnn::IWorkloadFactory& workloadFactory,
1007         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1008         const armnn::DataLayout layout);
1009
1010 LayerTestResult<float, 4> L2Normalization1dTest(
1011     armnn::IWorkloadFactory& workloadFactory,
1012     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1013     const armnn::DataLayout layout);
1014
1015 LayerTestResult<int16_t, 4> L2Normalization1dInt16Test(
1016     armnn::IWorkloadFactory& workloadFactory,
1017     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1018     const armnn::DataLayout layout);
1019
1020 LayerTestResult<uint8_t, 4> L2Normalization1dUint8Test(
1021         armnn::IWorkloadFactory& workloadFactory,
1022         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1023         const armnn::DataLayout layout);
1024
1025 LayerTestResult<float, 4> L2Normalization2dTest(
1026     armnn::IWorkloadFactory& workloadFactory,
1027     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1028     const armnn::DataLayout layout);
1029
1030 LayerTestResult<int16_t, 4> L2Normalization2dInt16Test(
1031     armnn::IWorkloadFactory& workloadFactory,
1032     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1033     const armnn::DataLayout layout);
1034
1035 LayerTestResult<uint8_t, 4> L2Normalization2dUint8Test(
1036         armnn::IWorkloadFactory& workloadFactory,
1037         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1038         const armnn::DataLayout layout);
1039
1040 LayerTestResult<float, 4> L2Normalization3dTest(
1041     armnn::IWorkloadFactory& workloadFactory,
1042     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1043     const armnn::DataLayout layout);
1044
1045 LayerTestResult<int16_t, 4> L2Normalization3dInt16Test(
1046     armnn::IWorkloadFactory& workloadFactory,
1047     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1048     const armnn::DataLayout layout);
1049
1050 LayerTestResult<uint8_t, 4> L2Normalization3dUint8Test(
1051         armnn::IWorkloadFactory& workloadFactory,
1052         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1053         const armnn::DataLayout layout);
1054
1055 LayerTestResult<float, 4> L2Normalization4dTest(
1056     armnn::IWorkloadFactory& workloadFactory,
1057     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1058     const armnn::DataLayout layout);
1059
1060 LayerTestResult<int16_t, 4> L2Normalization4dInt16Test(
1061     armnn::IWorkloadFactory& workloadFactory,
1062     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1063     const armnn::DataLayout layout);
1064
1065 LayerTestResult<uint8_t, 4> L2Normalization4dUint8Test(
1066         armnn::IWorkloadFactory& workloadFactory,
1067         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1068         const armnn::DataLayout layout);
1069
1070 LayerTestResult<float, 4> ConstantTest(
1071     armnn::IWorkloadFactory& workloadFactory,
1072     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1073
1074 LayerTestResult<uint8_t, 4> ConstantUint8SimpleQuantizationScaleNoOffsetTest(
1075     armnn::IWorkloadFactory& workloadFactory,
1076     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1077
1078 LayerTestResult<int16_t, 4> ConstantInt16SimpleQuantizationScaleNoOffsetTest(
1079     armnn::IWorkloadFactory& workloadFactory,
1080     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1081
1082 LayerTestResult<uint8_t, 4> BoundedReLuUint8Test(
1083     armnn::IWorkloadFactory& workloadFactory,
1084     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1085     float upperBound);
1086
1087 LayerTestResult<uint8_t, 4> BoundedReLuUint8Test(
1088     armnn::IWorkloadFactory& workloadFactory,
1089     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1090     float upperBound,
1091     float lowerBound);
1092
1093 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
1094 LayerTestResult<T, 2> FullyConnectedTest(
1095     armnn::IWorkloadFactory& workloadFactory,
1096     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1097     bool biasEnabled);
1098
1099 std::vector<LayerTestResult<uint8_t, 3>> SplitterUint8Test(
1100     armnn::IWorkloadFactory& workloadFactory,
1101     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1102
1103 std::vector<LayerTestResult<int16_t, 3>> SplitterInt16Test(
1104     armnn::IWorkloadFactory& workloadFactory,
1105     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1106
1107 LayerTestResult<uint8_t, 3> CopyViaSplitterUint8Test(
1108     armnn::IWorkloadFactory& workloadFactory,
1109     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1110
1111 LayerTestResult<int16_t, 3> CopyViaSplitterInt16Test(
1112     armnn::IWorkloadFactory& workloadFactory,
1113     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1114
1115 LayerTestResult<uint8_t, 3> ConcatUint8Test(
1116     armnn::IWorkloadFactory& workloadFactory,
1117     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1118
1119 LayerTestResult<uint16_t, 3> ConcatUint16Test(
1120     armnn::IWorkloadFactory& workloadFactory,
1121     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1122
1123 LayerTestResult<uint8_t, 3> ConcatUint8DifferentQParamsTest(
1124     armnn::IWorkloadFactory& workloadFactory,
1125     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1126
1127 LayerTestResult<uint8_t, 4> AdditionUint8Test(
1128     armnn::IWorkloadFactory& workloadFactory,
1129     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1130
1131 LayerTestResult<uint8_t, 4> AdditionBroadcast1ElementUint8Test(
1132     armnn::IWorkloadFactory& workloadFactory,
1133     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1134
1135 LayerTestResult<uint8_t, 4> AdditionBroadcastUint8Test(
1136     armnn::IWorkloadFactory& workloadFactory,
1137     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1138
1139 LayerTestResult<int16_t, 4> AdditionInt16Test(
1140     armnn::IWorkloadFactory& workloadFactory,
1141     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1142
1143 LayerTestResult<int16_t, 4> AdditionBroadcastInt16Test(
1144     armnn::IWorkloadFactory& workloadFactory,
1145     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1146
1147 LayerTestResult<int16_t, 4> AdditionBroadcast1ElementInt16Test(
1148     armnn::IWorkloadFactory& workloadFactory,
1149     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1150
1151 LayerTestResult<uint8_t, 4> SubtractionUint8Test(
1152     armnn::IWorkloadFactory& workloadFactory,
1153     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1154
1155 LayerTestResult<uint8_t, 4> SubtractionBroadcast1ElementUint8Test(
1156     armnn::IWorkloadFactory& workloadFactory,
1157     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1158
1159 LayerTestResult<uint8_t, 4> SubtractionBroadcastUint8Test(
1160     armnn::IWorkloadFactory& workloadFactory,
1161     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1162
1163 LayerTestResult<int16_t, 4> SubtractionInt16Test(
1164     armnn::IWorkloadFactory& workloadFactory,
1165     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1166
1167 LayerTestResult<int16_t, 4> SubtractionBroadcast1ElementInt16Test(
1168     armnn::IWorkloadFactory& workloadFactory,
1169     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1170
1171 LayerTestResult<int16_t, 4> SubtractionBroadcastInt16Test(
1172     armnn::IWorkloadFactory& workloadFactory,
1173     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1174
1175 LayerTestResult<uint8_t, 4> CompareActivationUint8Test(
1176     armnn::IWorkloadFactory& workloadFactory,
1177     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1178     armnn::IWorkloadFactory& refWorkloadFactory,
1179     armnn::ActivationFunction f);
1180
1181 LayerTestResult<int16_t, 4> CompareActivationInt16Test(
1182         armnn::IWorkloadFactory& workloadFactory,
1183         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1184         armnn::IWorkloadFactory& refWorkloadFactory,
1185         armnn::ActivationFunction f);
1186
1187 LayerTestResult<uint8_t, 2> CompareSoftmaxUint8Test(
1188     armnn::IWorkloadFactory& workloadFactory,
1189     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1190     armnn::IWorkloadFactory& refWorkloadFactory,
1191     float beta);
1192
1193 LayerTestResult<uint8_t, 4> MultiplicationUint8Test(
1194     armnn::IWorkloadFactory& workloadFactory,
1195     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1196
1197 LayerTestResult<uint8_t, 4> MultiplicationBroadcast1ElementUint8Test(
1198     armnn::IWorkloadFactory& workloadFactory,
1199     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1200
1201 LayerTestResult<uint8_t, 4> MultiplicationBroadcast1DVectorUint8Test(
1202     armnn::IWorkloadFactory& workloadFactory,
1203     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1204
1205 LayerTestResult<int16_t, 4> MultiplicationInt16Test(
1206     armnn::IWorkloadFactory& workloadFactory,
1207     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1208
1209 LayerTestResult<int16_t, 4> MultiplicationBroadcast1ElementInt16Test(
1210     armnn::IWorkloadFactory& workloadFactory,
1211     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1212
1213 LayerTestResult<int16_t, 4> MultiplicationBroadcast1DVectorInt16Test(
1214     armnn::IWorkloadFactory& workloadFactory,
1215     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1216
1217 LayerTestResult<uint8_t, 4> DivisionUint8Test(
1218     armnn::IWorkloadFactory& workloadFactory,
1219     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1220
1221 LayerTestResult<uint8_t, 4> DivisionBroadcast1ElementUint8Test(
1222     armnn::IWorkloadFactory& workloadFactory,
1223     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1224
1225 LayerTestResult<uint8_t, 4> DivisionBroadcast1DVectorUint8Test(
1226     armnn::IWorkloadFactory& workloadFactory,
1227     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1228
1229 LayerTestResult<int16_t, 4> DivisionInt16Test(
1230     armnn::IWorkloadFactory& workloadFactory,
1231     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1232
1233 LayerTestResult<int16_t, 4> DivisionBroadcast1ElementInt16Test(
1234     armnn::IWorkloadFactory& workloadFactory,
1235     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1236
1237 LayerTestResult<int16_t, 4> DivisionBroadcast1DVectorInt16Test(
1238     armnn::IWorkloadFactory& workloadFactory,
1239     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1240
1241 LayerTestResult<uint8_t, 4> SimpleConvolution2d3x5Uint8Test(
1242     armnn::IWorkloadFactory& workloadFactory,
1243     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1244     bool biasEnabled,
1245     const armnn::DataLayout layout);
1246
1247 LayerTestResult<uint8_t, 4> SimpleConvolution2d3x3Uint8Test(
1248     armnn::IWorkloadFactory& workloadFactory,
1249     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1250     bool biasEnabled,
1251     const armnn::DataLayout layout);
1252
1253 LayerTestResult<int16_t, 4> SimpleConvolution2d3x5QSymm16Test(
1254         armnn::IWorkloadFactory& workloadFactory,
1255         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1256         bool biasEnabled,
1257         const armnn::DataLayout layout);
1258
1259 LayerTestResult<int16_t, 4> SimpleConvolution2d3x3QSymm16Test(
1260         armnn::IWorkloadFactory& workloadFactory,
1261         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1262         bool biasEnabled,
1263         const armnn::DataLayout layout);
1264
1265 LayerTestResult<uint8_t, 4> DepthwiseConvolution2dUint8Test(
1266     armnn::IWorkloadFactory& workloadFactory,
1267     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1268     bool biasEnabled,
1269     const armnn::DataLayout layout);
1270
1271 LayerTestResult<uint8_t, 4> DepthwiseConvolution2dDepthMul1Uint8Test(
1272     armnn::IWorkloadFactory& workloadFactory,
1273     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1274     bool biasEnabled,
1275     const armnn::DataLayout layout);
1276
1277 LayerTestResult<int16_t, 4> DepthwiseConvolution2dInt16Test(
1278     armnn::IWorkloadFactory& workloadFactory,
1279     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1280     bool biasEnabled,
1281     const armnn::DataLayout layout);
1282
1283 LayerTestResult<int16_t, 4> DepthwiseConvolution2dDepthMul1Int16Test(
1284     armnn::IWorkloadFactory& workloadFactory,
1285     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1286     bool biasEnabled,
1287     const armnn::DataLayout layout);
1288
1289 LayerTestResult<uint8_t, 4> ConstantLinearActivationUint8Test(
1290     armnn::IWorkloadFactory& workloadFactory,
1291     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1292
1293 LayerTestResult<int16_t, 4> ConstantLinearActivationInt16Test(
1294     armnn::IWorkloadFactory& workloadFactory,
1295     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1296
1297 LayerTestResult<uint8_t, 4> BatchNormUint8Test(
1298     armnn::IWorkloadFactory& workloadFactory,
1299     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1300
1301 LayerTestResult<uint8_t, 4> BatchNormUint8NhwcTest(
1302     armnn::IWorkloadFactory& workloadFactory,
1303     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1304
1305 LayerTestResult<int16_t, 4> BatchNormInt16Test(
1306     armnn::IWorkloadFactory& workloadFactory,
1307     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1308
1309 LayerTestResult<int16_t, 4> BatchNormInt16NhwcTest(
1310     armnn::IWorkloadFactory& workloadFactory,
1311     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1312
1313 LayerTestResult<uint8_t, 4> ConstantUint8CustomQuantizationScaleAndOffsetTest(
1314     armnn::IWorkloadFactory& workloadFactory,
1315     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1316
1317 LayerTestResult<int16_t, 4> ConstantInt16CustomQuantizationScaleAndOffsetTest(
1318     armnn::IWorkloadFactory& workloadFactory,
1319     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1320
1321 LayerTestResult<uint8_t, 1> Concatenation1dUint8Test(
1322     armnn::IWorkloadFactory& workloadFactory,
1323     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1324
1325 LayerTestResult<uint8_t, 2> Concatenation2dDim0Uint8Test(
1326     armnn::IWorkloadFactory& workloadFactory,
1327     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1328
1329 LayerTestResult<uint8_t, 2> Concatenation2dDim1Uint8Test(
1330     armnn::IWorkloadFactory& workloadFactory,
1331     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1332
1333 LayerTestResult<uint8_t, 2> Concatenation2dDim0DiffInputDimsUint8Test(
1334     armnn::IWorkloadFactory& workloadFactory,
1335     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1336
1337 LayerTestResult<uint8_t, 2> Concatenation2dDim1DiffInputDimsUint8Test(
1338     armnn::IWorkloadFactory& workloadFactory,
1339     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1340
1341 LayerTestResult<uint8_t, 3> Concatenation3dDim0Uint8Test(
1342     armnn::IWorkloadFactory& workloadFactory,
1343     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1344
1345 LayerTestResult<uint8_t, 3> Concatenation3dDim1Uint8Test(
1346     armnn::IWorkloadFactory& workloadFactory,
1347     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1348
1349 LayerTestResult<uint8_t, 3> Concatenation3dDim2Uint8Test(
1350     armnn::IWorkloadFactory& workloadFactory,
1351     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1352     bool useSubtensor);
1353
1354 LayerTestResult<uint8_t, 3> Concatenation3dDim0DiffInputDimsUint8Test(
1355     armnn::IWorkloadFactory& workloadFactory,
1356     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1357
1358 LayerTestResult<uint8_t, 3> Concatenation3dDim1DiffInputDimsUint8Test(
1359     armnn::IWorkloadFactory& workloadFactory,
1360     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1361
1362 LayerTestResult<uint8_t, 3> Concatenation3dDim2DiffInputDimsUint8Test(
1363     armnn::IWorkloadFactory& workloadFactory,
1364     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1365     bool useSubtensor);
1366
1367 LayerTestResult<uint8_t, 4> EqualSimpleTest(
1368     armnn::IWorkloadFactory& workloadFactory,
1369     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1370
1371 LayerTestResult<uint8_t, 4> EqualBroadcast1ElementTest(
1372     armnn::IWorkloadFactory& workloadFactory,
1373     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1374
1375 LayerTestResult<uint8_t, 4> EqualBroadcast1DVectorTest(
1376     armnn::IWorkloadFactory& workloadFactory,
1377     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1378
1379 LayerTestResult<uint8_t, 4> EqualUint8Test(
1380     armnn::IWorkloadFactory& workloadFactory,
1381     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1382
1383 LayerTestResult<uint8_t, 4> EqualBroadcast1ElementUint8Test(
1384     armnn::IWorkloadFactory& workloadFactory,
1385     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1386
1387 LayerTestResult<uint8_t, 4> EqualBroadcast1DVectorUint8Test(
1388     armnn::IWorkloadFactory& workloadFactory,
1389     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1390
1391 LayerTestResult<uint8_t, 4> GreaterSimpleTest(
1392     armnn::IWorkloadFactory& workloadFactory,
1393     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1394
1395 LayerTestResult<uint8_t, 4> GreaterBroadcast1ElementTest(
1396     armnn::IWorkloadFactory& workloadFactory,
1397     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1398
1399 LayerTestResult<uint8_t, 4> GreaterBroadcast1DVectorTest(
1400     armnn::IWorkloadFactory& workloadFactory,
1401     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1402
1403 LayerTestResult<uint8_t, 4> GreaterUint8Test(
1404     armnn::IWorkloadFactory& workloadFactory,
1405     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1406
1407 LayerTestResult<uint8_t, 4> GreaterBroadcast1ElementUint8Test(
1408     armnn::IWorkloadFactory& workloadFactory,
1409     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1410
1411 LayerTestResult<uint8_t, 4> GreaterBroadcast1DVectorUint8Test(
1412     armnn::IWorkloadFactory& workloadFactory,
1413     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1414
1415 LayerTestResult<float, 2> FullyConnectedLargeTest(
1416     armnn::IWorkloadFactory& workloadFactory,
1417     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1418     bool transposeWeights);
1419
1420 LayerTestResult<uint8_t, 2> PadUint82dTest(
1421     armnn::IWorkloadFactory& workloadFactory,
1422     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1423
1424 LayerTestResult<uint8_t, 2> PadUint82dCustomPaddingTest(
1425     armnn::IWorkloadFactory& workloadFactory,
1426     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1427
1428 LayerTestResult<uint8_t, 3> PadUint83dTest(
1429     armnn::IWorkloadFactory& workloadFactory,
1430     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1431
1432 LayerTestResult<uint8_t, 4> PadUint84dTest(
1433     armnn::IWorkloadFactory& workloadFactory,
1434     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1435
1436 LayerTestResult<float, 2> PadFloat322dTest(
1437     armnn::IWorkloadFactory& workloadFactory,
1438     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1439
1440 LayerTestResult<float, 2> PadFloat322dCustomPaddingTest(
1441     armnn::IWorkloadFactory& workloadFactory,
1442     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1443
1444 LayerTestResult<float, 3> PadFloat323dTest(
1445     armnn::IWorkloadFactory& workloadFactory,
1446     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1447
1448 LayerTestResult<float, 4> PadFloat324dTest(
1449     armnn::IWorkloadFactory& workloadFactory,
1450     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1451
1452 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
1453 LayerTestResult<T, 2> Pad2dTestCommon(
1454     armnn::IWorkloadFactory& workloadFactory,
1455     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1456     float qScale,
1457     int32_t qOffset,
1458     const float customPaddingValue = 0.0f);
1459
1460 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
1461 LayerTestResult<T, 3> Pad3dTestCommon(
1462     armnn::IWorkloadFactory& workloadFactory,
1463     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1464     float qScale,
1465     int32_t qOffset);
1466
1467 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
1468 LayerTestResult<T, 4> Pad4dTestCommon(
1469     armnn::IWorkloadFactory& workloadFactory,
1470     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
1471     float qScale,
1472     int32_t qOffset);
1473
1474 void LstmUtilsZeroVectorTest();
1475 void LstmUtilsMeanStddevNormalizationNoneZeroInputTest();
1476 void LstmUtilsMeanStddevNormalizationAllZeroInputTest();
1477 void LstmUtilsMeanStddevNormalizationMixedZeroInputTest();
1478 void LstmUtilsVectorBatchVectorCwiseProductTest();
1479 void LstmUtilsVectorBatchVectorAddTest();
1480
1481 LayerTestResult<float, 2> LstmLayerFloat32WithCifgWithPeepholeNoProjectionTest(
1482     armnn::IWorkloadFactory& workloadFactory,
1483     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1484
1485 LayerTestResult<float, 2> LstmLayerFloat32NoCifgNoPeepholeNoProjectionTest(
1486     armnn::IWorkloadFactory& workloadFactory,
1487     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1488
1489 LayerTestResult<float, 2> LstmLayerFloat32NoCifgWithPeepholeWithProjectionTest(
1490     armnn::IWorkloadFactory& workloadFactory,
1491     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1492
1493 LayerTestResult<float, 2> LstmLayerFloat32NoCifgWithPeepholeWithProjectionWithLayerNormTest(
1494         armnn::IWorkloadFactory& workloadFactory,
1495         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1496
1497 LayerTestResult<int16_t, 2> LstmLayerInt16NoCifgNoPeepholeNoProjectionTest(
1498     armnn::IWorkloadFactory& workloadFactory,
1499     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1500
1501 LayerTestResult<int16_t, 2> LstmLayerInt16WithCifgWithPeepholeNoProjectionTest(
1502     armnn::IWorkloadFactory& workloadFactory,
1503     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1504
1505 LayerTestResult<int16_t, 2> LstmLayerInt16NoCifgWithPeepholeWithProjectionTest(
1506     armnn::IWorkloadFactory& workloadFactory,
1507     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1508
1509 LayerTestResult<int16_t, 2> LstmLayerInt16NoCifgNoPeepholeNoProjectionInt16ConstantTest(
1510     armnn::IWorkloadFactory& workloadFactory,
1511     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1512
1513 LayerTestResult<float, 4> SimpleConvertFp16ToFp32Test(
1514     armnn::IWorkloadFactory& workloadFactory,
1515     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1516
1517 LayerTestResult<armnn::Half, 4> SimpleConvertFp32ToFp16Test(
1518     armnn::IWorkloadFactory& workloadFactory,
1519     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1520
1521 LayerTestResult<float, 4> MaximumSimpleTest(
1522         armnn::IWorkloadFactory& workloadFactory,
1523         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1524
1525 LayerTestResult<float, 4> MaximumBroadcast1ElementTest(
1526         armnn::IWorkloadFactory& workloadFactory,
1527         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1528
1529 LayerTestResult<float, 4> MaximumBroadcast1DVectorTest(
1530         armnn::IWorkloadFactory& workloadFactory,
1531         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1532
1533 LayerTestResult<uint8_t , 4> MaximumUint8Test(
1534         armnn::IWorkloadFactory& workloadFactory,
1535         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1536
1537 LayerTestResult<uint8_t, 4> MaximumBroadcast1ElementUint8Test(
1538         armnn::IWorkloadFactory& workloadFactory,
1539         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1540
1541 LayerTestResult<uint8_t, 4> MaximumBroadcast1DVectorUint8Test(
1542         armnn::IWorkloadFactory& workloadFactory,
1543         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1544
1545 LayerTestResult<int16_t , 4> MaximumInt16Test(
1546     armnn::IWorkloadFactory& workloadFactory,
1547     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1548
1549 LayerTestResult<int16_t, 4> MaximumBroadcast1ElementInt16Test(
1550     armnn::IWorkloadFactory& workloadFactory,
1551     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1552
1553 LayerTestResult<int16_t, 4> MaximumBroadcast1DVectorInt16Test(
1554     armnn::IWorkloadFactory& workloadFactory,
1555     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1556
1557 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
1558 LayerTestResult<T, 1> MeanSimpleTest(
1559     armnn::IWorkloadFactory& workloadFactory,
1560     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1561
1562 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
1563 LayerTestResult<T, 3> MeanSimpleAxisTest(
1564     armnn::IWorkloadFactory& workloadFactory,
1565     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1566
1567 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
1568 LayerTestResult<T, 4> MeanKeepDimsTest(
1569     armnn::IWorkloadFactory& workloadFactory,
1570     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1571
1572 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
1573 LayerTestResult<T, 4> MeanMultipleDimsTest(
1574     armnn::IWorkloadFactory& workloadFactory,
1575     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1576
1577 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
1578 LayerTestResult<T, 1> MeanVts1Test(
1579     armnn::IWorkloadFactory& workloadFactory,
1580     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1581
1582 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
1583 LayerTestResult<T, 3> MeanVts2Test(
1584     armnn::IWorkloadFactory& workloadFactory,
1585     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1586
1587 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
1588 LayerTestResult<T, 3> MeanVts3Test(
1589     armnn::IWorkloadFactory& workloadFactory,
1590     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1591
1592 LayerTestResult<float, 4> MinimumBroadcast1ElementTest1(
1593     armnn::IWorkloadFactory& workloadFactory,
1594     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1595
1596 LayerTestResult<float, 4> MinimumBroadcast1ElementTest2(
1597     armnn::IWorkloadFactory& workloadFactory,
1598     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1599
1600 LayerTestResult<uint8_t, 4> MinimumBroadcast1DVectorUint8Test(
1601     armnn::IWorkloadFactory & workloadFactory,
1602     const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager);
1603
1604 LayerTestResult<int16_t , 4> MinimumInt16Test(
1605     armnn::IWorkloadFactory& workloadFactory,
1606     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1607
1608 LayerTestResult<int16_t, 4> MinimumBroadcast1ElementInt16Test(
1609     armnn::IWorkloadFactory& workloadFactory,
1610     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1611
1612 LayerTestResult<int16_t, 4> MinimumBroadcast1DVectorInt16Test(
1613     armnn::IWorkloadFactory& workloadFactory,
1614     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1615
1616 LayerTestResult<float, 4> AdditionAfterMaxPoolTest(
1617     armnn::IWorkloadFactory& workloadFactory,
1618     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1619
1620 LayerTestResult<float, 4> SpaceToBatchNdSimpleFloat32Test(
1621     armnn::IWorkloadFactory& workloadFactory,
1622     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1623
1624 LayerTestResult<float, 4> SpaceToBatchNdMultiChannelsFloat32Test(
1625     armnn::IWorkloadFactory& workloadFactory,
1626     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1627
1628 LayerTestResult<float, 4> SpaceToBatchNdMultiBlockFloat32Test(
1629     armnn::IWorkloadFactory& workloadFactory,
1630     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1631
1632 LayerTestResult<float, 4> SpaceToBatchNdPaddingFloat32Test(
1633     armnn::IWorkloadFactory& workloadFactory,
1634     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1635
1636 LayerTestResult<uint8_t, 4> SpaceToBatchNdSimpleUint8Test(
1637     armnn::IWorkloadFactory& workloadFactory,
1638     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1639
1640 LayerTestResult<uint8_t, 4> SpaceToBatchNdMultiChannelsUint8Test(
1641     armnn::IWorkloadFactory& workloadFactory,
1642     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1643
1644 LayerTestResult<uint8_t, 4> SpaceToBatchNdMultiBlockUint8Test(
1645     armnn::IWorkloadFactory& workloadFactory,
1646     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1647
1648 LayerTestResult<uint8_t, 4> SpaceToBatchNdPaddingUint8Test(
1649     armnn::IWorkloadFactory& workloadFactory,
1650     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1651
1652 LayerTestResult<float, 4> SpaceToBatchNdSimpleNHWCFloat32Test(
1653     armnn::IWorkloadFactory& workloadFactory,
1654     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1655
1656 LayerTestResult<float, 4> SpaceToBatchNdMultiChannelsNHWCFloat32Test(
1657     armnn::IWorkloadFactory& workloadFactory,
1658     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1659
1660 LayerTestResult<float, 4> SpaceToBatchNdMultiBlockNHWCFloat32Test(
1661     armnn::IWorkloadFactory& workloadFactory,
1662     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1663
1664 LayerTestResult<float, 4> SpaceToBatchNdPaddingNHWCFloat32Test(
1665     armnn::IWorkloadFactory& workloadFactory,
1666     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1667
1668 LayerTestResult<uint8_t, 4> SpaceToBatchNdSimpleNHWCUint8Test(
1669     armnn::IWorkloadFactory& workloadFactory,
1670     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1671
1672 LayerTestResult<uint8_t, 4> SpaceToBatchNdMultiChannelsNHWCUint8Test(
1673     armnn::IWorkloadFactory& workloadFactory,
1674     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1675
1676 LayerTestResult<uint8_t, 4> SpaceToBatchNdMultiBlockNHWCUint8Test(
1677     armnn::IWorkloadFactory& workloadFactory,
1678     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1679
1680 LayerTestResult<uint8_t, 4> SpaceToBatchNdPaddingNHWCUint8Test(
1681     armnn::IWorkloadFactory& workloadFactory,
1682     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1683
1684 LayerTestResult<int16_t, 4> SpaceToBatchNdSimpleUint16Test(
1685         armnn::IWorkloadFactory& workloadFactory,
1686         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1687
1688 LayerTestResult<int16_t, 4> SpaceToBatchNdMultiChannelsUint16Test(
1689         armnn::IWorkloadFactory& workloadFactory,
1690         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1691
1692 LayerTestResult<int16_t, 4> SpaceToBatchNdMultiBlockUint16Test(
1693         armnn::IWorkloadFactory& workloadFactory,
1694         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1695
1696 LayerTestResult<int16_t, 4> SpaceToBatchNdPaddingUint16Test(
1697         armnn::IWorkloadFactory& workloadFactory,
1698         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1699
1700 LayerTestResult<int16_t, 4> SpaceToBatchNdSimpleNHWCUint16Test(
1701         armnn::IWorkloadFactory& workloadFactory,
1702         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1703
1704 LayerTestResult<int16_t, 4> SpaceToBatchNdMultiChannelsNHWCUint16Test(
1705         armnn::IWorkloadFactory& workloadFactory,
1706         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1707
1708 LayerTestResult<int16_t, 4> SpaceToBatchNdMultiBlockNHWCUint16Test(
1709         armnn::IWorkloadFactory& workloadFactory,
1710         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1711
1712 LayerTestResult<int16_t, 4> SpaceToBatchNdPaddingNHWCUint16Test(
1713         armnn::IWorkloadFactory& workloadFactory,
1714         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1715
1716 LayerTestResult<float, 4> BatchToSpaceNdNhwcTest1(
1717     armnn::IWorkloadFactory& workloadFactory,
1718     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1719
1720 LayerTestResult<float, 4> BatchToSpaceNdNhwcTest2(
1721     armnn::IWorkloadFactory& workloadFactory,
1722     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1723
1724 LayerTestResult<float, 4> BatchToSpaceNdNhwcTest3(
1725     armnn::IWorkloadFactory& workloadFactory,
1726     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1727
1728 LayerTestResult<float, 4> BatchToSpaceNdNhwcTest4(
1729     armnn::IWorkloadFactory& workloadFactory,
1730     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1731
1732 LayerTestResult<float, 4> BatchToSpaceNdNchwTest1(
1733     armnn::IWorkloadFactory &workloadFactory,
1734     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1735
1736 LayerTestResult<float, 4> BatchToSpaceNdNchwTest2(
1737     armnn::IWorkloadFactory &workloadFactory,
1738     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1739
1740 LayerTestResult<float, 4> BatchToSpaceNdNchwTest3(
1741     armnn::IWorkloadFactory &workloadFactory,
1742     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1743
1744 LayerTestResult<uint8_t, 4> BatchToSpaceNdNhwcTest5(
1745     armnn::IWorkloadFactory &workloadFactory,
1746     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1747
1748 LayerTestResult<uint8_t, 4> BatchToSpaceNdNhwcTest6(
1749     armnn::IWorkloadFactory &workloadFactory,
1750     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1751
1752 LayerTestResult<uint8_t, 4> BatchToSpaceNdNhwcTest7(
1753     armnn::IWorkloadFactory &workloadFactory,
1754     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1755
1756 LayerTestResult<uint8_t, 4> BatchToSpaceNdNchwTest4(
1757     armnn::IWorkloadFactory &workloadFactory,
1758     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1759
1760 LayerTestResult<uint8_t, 4> BatchToSpaceNdNchwTest5(
1761     armnn::IWorkloadFactory &workloadFactory,
1762     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1763
1764 LayerTestResult<uint8_t, 4> BatchToSpaceNdNchwTest6(
1765     armnn::IWorkloadFactory &workloadFactory,
1766     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1767
1768 LayerTestResult<uint8_t, 4> BatchToSpaceNdNchwTest7(
1769     armnn::IWorkloadFactory &workloadFactory,
1770     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1771
1772 LayerTestResult<float, 4> StridedSlice4DFloat32Test(
1773     armnn::IWorkloadFactory& workloadFactory,
1774     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1775
1776 LayerTestResult<float, 4> StridedSlice4DReverseFloat32Test(
1777     armnn::IWorkloadFactory& workloadFactory,
1778     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1779
1780 LayerTestResult<float, 4> StridedSliceSimpleStrideFloat32Test(
1781     armnn::IWorkloadFactory& workloadFactory,
1782     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1783
1784 LayerTestResult<float, 4> StridedSliceSimpleRangeMaskFloat32Test(
1785     armnn::IWorkloadFactory& workloadFactory,
1786     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1787
1788 LayerTestResult<float, 2> StridedSliceShrinkAxisMaskFloat32Test(
1789     armnn::IWorkloadFactory& workloadFactory,
1790     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1791
1792 LayerTestResult<float, 3> StridedSlice3DFloat32Test(
1793     armnn::IWorkloadFactory& workloadFactory,
1794     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1795
1796 LayerTestResult<float, 3> StridedSlice3DReverseFloat32Test(
1797     armnn::IWorkloadFactory& workloadFactory,
1798     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1799
1800 LayerTestResult<float, 2> StridedSlice2DFloat32Test(
1801     armnn::IWorkloadFactory& workloadFactory,
1802     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1803
1804 LayerTestResult<float, 2> StridedSlice2DReverseFloat32Test(
1805     armnn::IWorkloadFactory& workloadFactory,
1806     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1807
1808 LayerTestResult<uint8_t, 4> StridedSlice4DUint8Test(
1809     armnn::IWorkloadFactory& workloadFactory,
1810     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1811
1812 LayerTestResult<uint8_t, 4> StridedSlice4DReverseUint8Test(
1813     armnn::IWorkloadFactory& workloadFactory,
1814     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1815
1816 LayerTestResult<uint8_t, 4> StridedSliceSimpleStrideUint8Test(
1817     armnn::IWorkloadFactory& workloadFactory,
1818     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1819
1820 LayerTestResult<uint8_t, 4> StridedSliceSimpleRangeMaskUint8Test(
1821     armnn::IWorkloadFactory& workloadFactory,
1822     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1823
1824 LayerTestResult<uint8_t, 2> StridedSliceShrinkAxisMaskUint8Test(
1825     armnn::IWorkloadFactory& workloadFactory,
1826     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1827
1828 LayerTestResult<uint8_t, 3> StridedSlice3DUint8Test(
1829     armnn::IWorkloadFactory& workloadFactory,
1830     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1831
1832 LayerTestResult<uint8_t, 3> StridedSlice3DReverseUint8Test(
1833     armnn::IWorkloadFactory& workloadFactory,
1834     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1835
1836 LayerTestResult<uint8_t, 2> StridedSlice2DUint8Test(
1837     armnn::IWorkloadFactory& workloadFactory,
1838     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1839
1840 LayerTestResult<uint8_t, 2> StridedSlice2DReverseUint8Test(
1841     armnn::IWorkloadFactory& workloadFactory,
1842     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1843
1844 LayerTestResult<int16_t, 4> StridedSlice4DInt16Test(
1845     armnn::IWorkloadFactory& workloadFactory,
1846     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1847
1848 LayerTestResult<int16_t, 4> StridedSlice4DReverseInt16Test(
1849     armnn::IWorkloadFactory& workloadFactory,
1850     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1851
1852 LayerTestResult<int16_t, 4> StridedSliceSimpleStrideInt16Test(
1853     armnn::IWorkloadFactory& workloadFactory,
1854     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1855
1856 LayerTestResult<int16_t, 4> StridedSliceSimpleRangeMaskInt16Test(
1857     armnn::IWorkloadFactory& workloadFactory,
1858     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1859
1860 LayerTestResult<int16_t, 2> StridedSliceShrinkAxisMaskInt16Test(
1861     armnn::IWorkloadFactory& workloadFactory,
1862     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1863
1864 LayerTestResult<int16_t, 3> StridedSlice3DInt16Test(
1865     armnn::IWorkloadFactory& workloadFactory,
1866     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1867
1868 LayerTestResult<int16_t, 3> StridedSlice3DReverseInt16Test(
1869     armnn::IWorkloadFactory& workloadFactory,
1870     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1871
1872 LayerTestResult<int16_t, 2> StridedSlice2DInt16Test(
1873     armnn::IWorkloadFactory& workloadFactory,
1874     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1875
1876 LayerTestResult<int16_t, 2> StridedSlice2DReverseInt16Test(
1877     armnn::IWorkloadFactory& workloadFactory,
1878     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1879
1880 LayerTestResult<float, 4> Debug4DFloat32Test(
1881     armnn::IWorkloadFactory& workloadFactory,
1882     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1883
1884 LayerTestResult<float, 3> Debug3DFloat32Test(
1885     armnn::IWorkloadFactory& workloadFactory,
1886     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1887
1888 LayerTestResult<float, 2> Debug2DFloat32Test(
1889     armnn::IWorkloadFactory& workloadFactory,
1890     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1891
1892 LayerTestResult<float, 1> Debug1DFloat32Test(
1893     armnn::IWorkloadFactory& workloadFactory,
1894     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1895
1896 LayerTestResult<uint8_t, 4> Debug4DUint8Test(
1897     armnn::IWorkloadFactory& workloadFactory,
1898     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1899
1900 LayerTestResult<uint8_t, 3> Debug3DUint8Test(
1901     armnn::IWorkloadFactory& workloadFactory,
1902     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1903
1904 LayerTestResult<uint8_t, 2> Debug2DUint8Test(
1905     armnn::IWorkloadFactory& workloadFactory,
1906     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1907
1908 LayerTestResult<uint8_t, 1> Debug1DUint8Test(
1909     armnn::IWorkloadFactory& workloadFactory,
1910     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1911
1912 LayerTestResult<uint8_t, 4> PreCompiledConvolution2dTest(
1913     armnn::IWorkloadFactory& workloadFactory,
1914     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1915
1916 LayerTestResult<uint8_t, 4> PreCompiledConvolution2dStride2x2Test(
1917     armnn::IWorkloadFactory& workloadFactory,
1918     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1919
1920 LayerTestResult<uint8_t, 4> PreCompiledDepthwiseConvolution2dTest(
1921     armnn::IWorkloadFactory & workloadFactory,
1922     const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager);
1923
1924 LayerTestResult<uint8_t, 4> PreCompiledDepthwiseConvolution2dStride2x2Test(
1925     armnn::IWorkloadFactory & workloadFactory,
1926     const armnn::IBackendInternal::IMemoryManagerSharedPtr & memoryManager);
1927
1928 LayerTestResult<uint8_t, 4> PreCompiledMaxPooling2dTest(
1929     armnn::IWorkloadFactory& workloadFactory,
1930     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1931
1932 LayerTestResult<float, 4> Debug4DFloat32Test(
1933     armnn::IWorkloadFactory& workloadFactory,
1934     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1935
1936 LayerTestResult<float, 3> Debug3DFloat32Test(
1937     armnn::IWorkloadFactory& workloadFactory,
1938     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1939
1940 LayerTestResult<float, 2> Debug2DFloat32Test(
1941     armnn::IWorkloadFactory& workloadFactory,
1942     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1943
1944 LayerTestResult<float, 1> Debug1DFloat32Test(
1945     armnn::IWorkloadFactory& workloadFactory,
1946     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1947
1948 LayerTestResult<uint8_t, 4> Debug4DUint8Test(
1949     armnn::IWorkloadFactory& workloadFactory,
1950     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1951
1952 LayerTestResult<uint8_t, 3> Debug3DUint8Test(
1953     armnn::IWorkloadFactory& workloadFactory,
1954     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1955
1956 LayerTestResult<uint8_t, 2> Debug2DUint8Test(
1957     armnn::IWorkloadFactory& workloadFactory,
1958     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1959
1960 LayerTestResult<uint8_t, 1> Debug1DUint8Test(
1961     armnn::IWorkloadFactory& workloadFactory,
1962     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1963
1964 LayerTestResult<float, 1> Gather1DParamsFloatTest(
1965     armnn::IWorkloadFactory& workloadFactory,
1966     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1967
1968 LayerTestResult<uint8_t, 1> Gather1DParamsUint8Test(
1969     armnn::IWorkloadFactory& workloadFactory,
1970     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1971
1972 LayerTestResult<int16_t, 1> Gather1DParamsInt16Test(
1973     armnn::IWorkloadFactory& workloadFactory,
1974     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1975
1976 LayerTestResult<float, 2> GatherMultiDimParamsFloatTest(
1977     armnn::IWorkloadFactory& workloadFactory,
1978     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1979
1980 LayerTestResult<uint8_t, 2> GatherMultiDimParamsUint8Test(
1981     armnn::IWorkloadFactory& workloadFactory,
1982     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1983
1984 LayerTestResult<int16_t, 2> GatherMultiDimParamsInt16Test(
1985     armnn::IWorkloadFactory& workloadFactory,
1986     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1987
1988 LayerTestResult<float, 4> GatherMultiDimParamsMultiDimIndicesFloatTest(
1989     armnn::IWorkloadFactory& workloadFactory,
1990     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1991
1992 LayerTestResult<uint8_t, 4> GatherMultiDimParamsMultiDimIndicesUint8Test(
1993     armnn::IWorkloadFactory& workloadFactory,
1994     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1995
1996 LayerTestResult<int16_t, 4> GatherMultiDimParamsMultiDimIndicesInt16Test(
1997     armnn::IWorkloadFactory& workloadFactory,
1998     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
1999
2000 LayerTestResult<float, 4> DequantizeSimpleUint8Test(
2001     armnn::IWorkloadFactory& workloadFactory,
2002     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
2003
2004 LayerTestResult<float, 4> DequantizeOffsetUint8Test(
2005     armnn::IWorkloadFactory& workloadFactory,
2006     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
2007
2008 LayerTestResult<float, 4> DequantizeSimpleInt16Test(
2009     armnn::IWorkloadFactory& workloadFactory,
2010     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
2011
2012 LayerTestResult<uint8_t, 4> SpaceToDepthNCHWAsymmQ8Test(
2013     armnn::IWorkloadFactory& workloadFactory,
2014     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
2015
2016 LayerTestResult<uint8_t, 4> SpaceToDepthNHWCAsymmQ8Test(
2017     armnn::IWorkloadFactory& workloadFactory,
2018     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
2019
2020 LayerTestResult<float, 4> SpaceToDepthNHWCFloat32Test1(
2021     armnn::IWorkloadFactory& workloadFactory,
2022     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
2023
2024 LayerTestResult<float, 4> SpaceToDepthNCHWFloat32Test1(
2025     armnn::IWorkloadFactory& workloadFactory,
2026     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
2027
2028 LayerTestResult<float, 4> SpaceToDepthNHWCFloat32Test2(
2029     armnn::IWorkloadFactory& workloadFactory,
2030     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
2031
2032 LayerTestResult<float, 4> SpaceToDepthNCHWFloat32Test2(
2033     armnn::IWorkloadFactory& workloadFactory,
2034     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
2035
2036 LayerTestResult<int16_t, 4> SpaceToDepthNHWCQSymm16Test(
2037     armnn::IWorkloadFactory& workloadFactory,
2038     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
2039
2040 LayerTestResult<int16_t, 4> SpaceToDepthNCHWQSymm16Test(
2041     armnn::IWorkloadFactory& workloadFactory,
2042     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
2043
2044 LayerTestResult<uint8_t, 4> QuantizeSimpleUint8Test(
2045     armnn::IWorkloadFactory& workloadFactory,
2046     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
2047
2048 LayerTestResult<uint8_t, 4> QuantizeClampUint8Test(
2049     armnn::IWorkloadFactory& workloadFactory,
2050     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
2051
2052 LayerTestResult<int16_t, 4> QuantizeClampInt16Test(
2053     armnn::IWorkloadFactory& workloadFactory,
2054     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
2055
2056 template<typename T, typename B>
2057 LayerTestResult<T, 2> SimpleFullyConnectedTestImpl(
2058         armnn::IWorkloadFactory& workloadFactory,
2059         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
2060         armnn::TensorInfo inputTensorInfo,
2061         armnn::TensorInfo outputTensorInfo,
2062         armnn::TensorInfo weightsDesc,
2063         armnn::TensorInfo biasesDesc,
2064         boost::multi_array<T, 2>& weights,
2065         boost::multi_array<B, 1>& bias,
2066         boost::multi_array<T, 4>& input,
2067         bool biasEnabled,
2068         bool transposeWeights)
2069 {
2070     std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
2071     std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
2072
2073     armnn::FullyConnectedQueueDescriptor data;
2074     armnn::WorkloadInfo info;
2075     armnn::ScopedCpuTensorHandle weightsTensor(weightsDesc);
2076     armnn::ScopedCpuTensorHandle biasTensor(biasesDesc);
2077
2078     AllocateAndCopyDataToITensorHandle(&weightsTensor, &weights[0][0]);
2079     AllocateAndCopyDataToITensorHandle(&biasTensor, &bias[0]);
2080
2081     AddInputToWorkload(data, info, inputTensorInfo, inputHandle.get());
2082     AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
2083     data.m_Weight = &weightsTensor;
2084     data.m_Bias = &biasTensor;
2085     data.m_Parameters.m_BiasEnabled = biasEnabled;
2086     data.m_Parameters.m_TransposeWeightMatrix = transposeWeights;
2087
2088     std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateFullyConnected(data, info);
2089     LayerTestResult<T, 2> result(outputTensorInfo);
2090
2091     inputHandle->Allocate();
2092     outputHandle->Allocate();
2093     CopyDataToITensorHandle(inputHandle.get(), &input[0][0][0][0]);
2094
2095     ExecuteWorkload(*workload, memoryManager);
2096
2097     CopyDataFromITensorHandle(&result.output[0][0], outputHandle.get());
2098
2099     return result;
2100 }
2101
2102 template <armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
2103 std::vector<T> ConvertToDataType(const std::vector<float>& input,
2104                                  const armnn::TensorInfo& inputTensorInfo)
2105 {
2106     std::vector<T> output(input.size());
2107     auto outputTensorInfo = inputTensorInfo;
2108     outputTensorInfo.SetDataType(ArmnnType);
2109
2110     std::unique_ptr<armnn::Encoder<float>> pOutputEncoder = armnn::MakeEncoder<float>(outputTensorInfo, output.data());
2111     armnn::Encoder<float>& rOutputEncoder = *pOutputEncoder;
2112
2113     for (auto it = input.begin(); it != input.end(); ++it)
2114     {
2115         rOutputEncoder.Set(*it);
2116         ++rOutputEncoder;
2117     }
2118     return output;
2119 }
2120
2121 // Utility method to convert a single value to the correct type
2122 template <typename T>
2123 T ConvertToDataType(const float& value,
2124                     const armnn::TensorInfo& tensorInfo)
2125 {
2126     std::vector<T> output(1);
2127     std::unique_ptr<armnn::Encoder<float>> pEncoder = armnn::MakeEncoder<float>(tensorInfo, output.data());
2128     armnn::Encoder<float>& rEncoder = *pEncoder;
2129     rEncoder.Set(value);
2130     return output[0];
2131 }
2132
2133 template<armnn::DataType ArmnnType, typename T>
2134 LayerTestResult<T, 2> Rsqrt2dTestCommon(
2135         armnn::IWorkloadFactory& workloadFactory,
2136         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
2137         const armnn::TensorInfo inputTensorInfo,
2138         const armnn::TensorInfo outputTensorInfo,
2139         const std::vector<float>& inputValues,
2140         const std::vector<float>& expectedOutputValues)
2141 {
2142     auto inputTensor = MakeTensor<T, 2>(inputTensorInfo, ConvertToDataType<ArmnnType>(inputValues,inputTensorInfo));
2143
2144     LayerTestResult<T, 2> result(outputTensorInfo);
2145
2146     result.outputExpected = MakeTensor<T, 2>(outputTensorInfo,
2147                                              ConvertToDataType<ArmnnType>(expectedOutputValues,outputTensorInfo));
2148
2149     std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
2150     std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
2151
2152     armnn::RsqrtQueueDescriptor descriptor;
2153
2154     armnn::WorkloadInfo info;
2155
2156     AddInputToWorkload(descriptor, info, inputTensorInfo, inputHandle.get());
2157     AddOutputToWorkload(descriptor, info, outputTensorInfo, outputHandle.get());
2158
2159     std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateRsqrt(descriptor, info);
2160
2161     inputHandle->Allocate();
2162     outputHandle->Allocate();
2163
2164     CopyDataToITensorHandle(inputHandle.get(), &inputTensor[0][0]);
2165
2166     workload->PostAllocationConfigure();
2167     workload->Execute();
2168
2169     CopyDataFromITensorHandle(&result.output[0][0], outputHandle.get());
2170
2171     return result;
2172 }
2173
2174 template<armnn::DataType ArmnnType, typename T>
2175 LayerTestResult<T, 2> Rsqrt2dTest(
2176         armnn::IWorkloadFactory& workloadFactory,
2177         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
2178 {
2179     const armnn::TensorShape inputShape{ 2, 2 };
2180     const armnn::TensorShape outputShape{ 2, 2 };
2181
2182     armnn::TensorInfo inputTensorInfo(inputShape, ArmnnType);
2183     inputTensorInfo.SetQuantizationScale(0.1f);
2184     inputTensorInfo.SetQuantizationOffset(0);
2185
2186     armnn::TensorInfo outputTensorInfo(outputShape, ArmnnType);
2187     outputTensorInfo.SetQuantizationScale(0.1f);
2188     outputTensorInfo.SetQuantizationOffset(0);
2189
2190     std::vector<float> inputValues
2191     {
2192         1.f, 4.f,
2193         16.f, 25.f
2194     };
2195
2196     std::vector<float> expectedOutputValues
2197     {
2198         1.f, 0.5f,
2199         0.25f, 0.2f
2200     };
2201
2202     return Rsqrt2dTestCommon<ArmnnType>(workloadFactory, memoryManager,
2203                                 inputTensorInfo, outputTensorInfo,
2204                                 inputValues, expectedOutputValues);
2205 }
2206
2207 template<armnn::DataType ArmnnType, typename T>
2208 LayerTestResult<T, 3> Rsqrt3dTest(
2209         armnn::IWorkloadFactory& workloadFactory,
2210         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
2211 {
2212     const armnn::TensorShape inputShape{ 3, 1, 2 };
2213     const armnn::TensorShape outputShape{ 3, 1, 2 };
2214
2215     armnn::TensorInfo inputTensorInfo(inputShape, ArmnnType);
2216     inputTensorInfo.SetQuantizationScale(0.1f);
2217     inputTensorInfo.SetQuantizationOffset(0);
2218
2219     armnn::TensorInfo outputTensorInfo(outputShape, ArmnnType);
2220     outputTensorInfo.SetQuantizationScale(0.1f);
2221     outputTensorInfo.SetQuantizationOffset(0);
2222
2223     std::vector<float> inputValues
2224     {
2225         1.f, 4.f, 16.f,
2226         25.f, 64.f, 100.f
2227     };
2228
2229     std::vector<float> expectedOutputValues
2230     {
2231         1.f, 0.5f, 0.25f,
2232         0.2f, 0.125f, 0.1f
2233     };
2234
2235     auto inputTensor = MakeTensor<T, 3>(inputTensorInfo, ConvertToDataType<ArmnnType>(inputValues,inputTensorInfo));
2236
2237     LayerTestResult<T, 3> result(outputTensorInfo);
2238     result.outputExpected = MakeTensor<T, 3>(outputTensorInfo,
2239                                              ConvertToDataType<ArmnnType>(expectedOutputValues,outputTensorInfo));
2240
2241     std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
2242     std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
2243
2244     armnn::RsqrtQueueDescriptor descriptor;
2245
2246     armnn::WorkloadInfo info;
2247
2248     AddInputToWorkload(descriptor, info, inputTensorInfo, inputHandle.get());
2249     AddOutputToWorkload(descriptor, info, outputTensorInfo, outputHandle.get());
2250
2251     std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateRsqrt(descriptor, info);
2252
2253     inputHandle->Allocate();
2254     outputHandle->Allocate();
2255
2256     CopyDataToITensorHandle(inputHandle.get(), &inputTensor[0][0][0]);
2257
2258     workload->PostAllocationConfigure();
2259     workload->Execute();
2260
2261     CopyDataFromITensorHandle(&result.output[0][0][0], outputHandle.get());
2262
2263     return result;
2264 }
2265
2266 template<armnn::DataType ArmnnType, typename T>
2267 LayerTestResult<T, 2> RsqrtZeroTest(
2268         armnn::IWorkloadFactory& workloadFactory,
2269         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
2270 {
2271     const armnn::TensorShape inputShape{ 1, 2 };
2272     const armnn::TensorShape outputShape{ 1, 2 };
2273
2274     armnn::TensorInfo inputTensorInfo(inputShape, ArmnnType);
2275     inputTensorInfo.SetQuantizationScale(0.1f);
2276
2277     armnn::TensorInfo outputTensorInfo(outputShape, ArmnnType);
2278     outputTensorInfo.SetQuantizationScale(0.1f);
2279
2280     std::vector<float> inputValues
2281     {
2282         0.f, -0.f
2283     };
2284
2285     std::vector<float> expectedOutputValues
2286     {
2287         INFINITY, -INFINITY
2288     };
2289
2290     return Rsqrt2dTestCommon<ArmnnType>(workloadFactory, memoryManager,
2291                                 inputTensorInfo, outputTensorInfo,
2292                                 inputValues, expectedOutputValues);
2293 }
2294
2295 template<armnn::DataType ArmnnType, typename T>
2296 LayerTestResult<T, 2> RsqrtNegativeTest(
2297         armnn::IWorkloadFactory& workloadFactory,
2298         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
2299 {
2300     const armnn::TensorShape inputShape{ 1, 2 };
2301     const armnn::TensorShape outputShape{ 1, 2 };
2302
2303     armnn::TensorInfo inputTensorInfo(inputShape, ArmnnType);
2304     inputTensorInfo.SetQuantizationScale(0.1f);
2305     inputTensorInfo.SetQuantizationOffset(0);
2306
2307     armnn::TensorInfo outputTensorInfo(outputShape, ArmnnType);
2308     outputTensorInfo.SetQuantizationScale(0.1f);
2309     outputTensorInfo.SetQuantizationOffset(0);
2310
2311     std::vector<float> inputValues
2312     {
2313         -25.f, -16.f
2314     };
2315
2316     std::vector<float> expectedOutputValues
2317     {
2318         -NAN, -NAN
2319     };
2320
2321     return Rsqrt2dTestCommon<ArmnnType>(workloadFactory, memoryManager,
2322                                 inputTensorInfo, outputTensorInfo,
2323                                 inputValues, expectedOutputValues);
2324 }
2325
2326 template<typename T>
2327 LayerTestResult<T, 4> SimpleReshapeTestImpl(
2328     armnn::IWorkloadFactory& workloadFactory,
2329     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
2330     armnn::TensorInfo inputTensorInfo,
2331     armnn::TensorInfo outputTensorInfo,
2332     const std::vector<T>& inputData,
2333     const std::vector<T>& outputExpectedData)
2334 {
2335     auto input = MakeTensor<T, 4>(inputTensorInfo, inputData);
2336
2337     LayerTestResult<T, 4> ret(outputTensorInfo);
2338     ret.outputExpected = MakeTensor<T, 4>(outputTensorInfo, outputExpectedData);
2339
2340     std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
2341     std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
2342
2343     armnn::ReshapeQueueDescriptor data;
2344     armnn::WorkloadInfo info;
2345     AddInputToWorkload(data, info, inputTensorInfo, inputHandle.get());
2346     AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
2347
2348     std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateReshape(data, info);
2349
2350     inputHandle->Allocate();
2351     outputHandle->Allocate();
2352
2353     CopyDataToITensorHandle(inputHandle.get(), &input[0][0][0][0]);
2354
2355     workload->Execute();
2356
2357     CopyDataFromITensorHandle(&ret.output[0][0][0][0], outputHandle.get());
2358
2359     return ret;
2360 }
2361
2362 template<armnn::DataType ArmnnType, typename T>
2363 LayerTestResult<T, 2> FullyConnectedTest(
2364         armnn::IWorkloadFactory& workloadFactory,
2365         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
2366         bool biasEnabled)
2367 {
2368     constexpr static unsigned int inputWidth = 3u;
2369     constexpr static unsigned int inputHeight = 2u;
2370     constexpr static unsigned int inputChannels = 1u;
2371
2372     constexpr static unsigned int inputSize = inputWidth * inputHeight * inputChannels;
2373
2374     constexpr static unsigned int outputChannels = 2u;
2375
2376     armnn::TensorInfo inputTensorInfo({ 1, inputChannels, inputHeight, inputWidth }, ArmnnType);
2377     inputTensorInfo.SetQuantizationScale(0.1f);
2378     inputTensorInfo.SetQuantizationOffset(63);
2379
2380     armnn::TensorInfo outputTensorInfo({ 1, outputChannels }, ArmnnType);
2381     outputTensorInfo.SetQuantizationScale(5.f);
2382     outputTensorInfo.SetQuantizationOffset(biasEnabled ? -50 : 10);
2383
2384     armnn::TensorInfo weightsDesc({ outputChannels, inputSize }, ArmnnType);
2385     weightsDesc.SetQuantizationScale(0.2f);
2386     weightsDesc.SetQuantizationOffset(93);
2387
2388     armnn::TensorInfo biasesDesc({ outputChannels }, GetBiasTypeFromWeightsType(weightsDesc.GetDataType()).value());
2389     biasesDesc.SetQuantizationScale(inputTensorInfo.GetQuantizationScale() * weightsDesc.GetQuantizationScale());
2390     biasesDesc.SetQuantizationOffset(0);
2391
2392     LayerTestResult<T, 2> result(outputTensorInfo);
2393
2394     auto input = MakeTensor<T, 4>(inputTensorInfo, ConvertToDataType<ArmnnType>(
2395         {
2396             -1.2f, 6.1f, -3.5f,
2397             18.8f, -5.5f, 2.9f
2398         },
2399         inputTensorInfo));
2400
2401     auto weights = MakeTensor<T, 2>(weightsDesc, ConvertToDataType<ArmnnType>(
2402         {
2403             -8.4f, 20.0f, -10.4f, -8, 16.4f, -11.8f,
2404             23.4f, 10.4f, -14.0f, -3.8f, -11.8f, 11.4f
2405         },
2406         weightsDesc));
2407
2408     auto bias = MakeTensor<int32_t, 1>(biasesDesc, std::vector<int32_t>{9250, 67500});
2409
2410     result = SimpleFullyConnectedTestImpl<T>(
2411             workloadFactory,
2412             memoryManager,
2413             inputTensorInfo, outputTensorInfo,
2414             weightsDesc, biasesDesc,
2415             weights, bias, input,
2416             biasEnabled, true
2417     );
2418
2419     if (biasEnabled)
2420     {
2421         result.outputExpected = MakeTensor<T, 2>(outputTensorInfo,
2422                                                  ConvertToDataType<ArmnnType>({80.f, 1460.f}, outputTensorInfo));
2423     }
2424     else
2425     {
2426         result.outputExpected = MakeTensor<T, 2>(outputTensorInfo,
2427                                                  ConvertToDataType<ArmnnType>({-107.04f, 110.f}, outputTensorInfo));
2428     }
2429
2430     return result;
2431 }
2432
2433 template<armnn::DataType ArmnnType, typename T>
2434 LayerTestResult<T, 4> SimpleReshapeTest(
2435     armnn::IWorkloadFactory& workloadFactory,
2436     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
2437 {
2438     armnn::TensorInfo inputTensorInfo;
2439     armnn::TensorInfo outputTensorInfo;
2440
2441     unsigned int inputShape[] = { 2, 2, 3, 3 };
2442     unsigned int outputShape[] = { 2, 2, 9, 1 };
2443
2444     inputTensorInfo = armnn::TensorInfo(4, inputShape, ArmnnType);
2445     inputTensorInfo.SetQuantizationScale(1.0f);
2446     outputTensorInfo = armnn::TensorInfo(4, outputShape, ArmnnType);
2447     outputTensorInfo.SetQuantizationScale(1.0f);
2448
2449     auto input = ConvertToDataType<ArmnnType>(
2450         {
2451             0.0f, 1.0f, 2.0f,
2452             3.0f, 4.0f, 5.0f,
2453             6.0f, 7.0f, 8.0f,
2454
2455             9.0f, 10.0f, 11.0f,
2456             12.0f, 13.0f, 14.0f,
2457             15.0f, 16.0f, 17.0f,
2458
2459             18.0f, 19.0f, 20.0f,
2460             21.0f, 22.0f, 23.0f,
2461             24.0f, 25.0f, 26.0f,
2462
2463             27.0f, 28.0f, 29.0f,
2464             30.0f, 31.0f, 32.0f,
2465             33.0f, 34.0f, 35.0f,
2466         },
2467         inputTensorInfo);
2468
2469     auto outputExpected = ConvertToDataType<ArmnnType>(
2470         {
2471             0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f,
2472
2473             9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f,
2474
2475             18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f,
2476
2477             27.0f, 28.0f, 29.0f, 30.0f, 31.0f, 32.0f, 33.0f, 34.0f, 35.0f,
2478         },
2479         outputTensorInfo);
2480
2481     return SimpleReshapeTestImpl<T>(
2482         workloadFactory, memoryManager, inputTensorInfo, outputTensorInfo, input, outputExpected);
2483 }
2484
2485 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
2486 LayerTestResult<T, 4> SimpleFloorTest(
2487     armnn::IWorkloadFactory& workloadFactory,
2488     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
2489 {
2490     armnn::TensorInfo inputTensorInfo({1, 3, 2, 3}, ArmnnType);
2491     inputTensorInfo.SetQuantizationScale(0.1f);
2492
2493     armnn::TensorInfo outputTensorInfo(inputTensorInfo);
2494     outputTensorInfo.SetQuantizationScale(0.1f);
2495
2496     auto input = MakeTensor<T, 4>(inputTensorInfo, ConvertToDataType<ArmnnType>(
2497         { -37.5f, -15.2f, -8.76f, -2.0f, -1.5f, -1.3f, -0.5f, -0.4f, 0.0f,
2498         1.0f, 0.4f, 0.5f, 1.3f, 1.5f, 2.0f, 8.76f, 15.2f, 37.5f },
2499         inputTensorInfo));
2500
2501     LayerTestResult<T, 4> ret(outputTensorInfo);
2502     ret.outputExpected = MakeTensor<T, 4>(outputTensorInfo, ConvertToDataType<ArmnnType>(
2503         { -38.0f, -16.0f, -9.0f, -2.0f, -2.0f, -2.0f, -1.0f, -1.0f, 0.0f,
2504         1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 2.0f, 8.0f, 15.0f, 37.0f },
2505         outputTensorInfo));
2506
2507     std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
2508     std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
2509
2510     armnn::FloorQueueDescriptor data;
2511     armnn::WorkloadInfo info;
2512     AddInputToWorkload(data, info, inputTensorInfo, inputHandle.get());
2513     AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
2514
2515     std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateFloor(data, info);
2516
2517     inputHandle->Allocate();
2518     outputHandle->Allocate();
2519
2520     CopyDataToITensorHandle(inputHandle.get(), &input[0][0][0][0]);
2521
2522     workload->Execute();
2523
2524     CopyDataFromITensorHandle(&ret.output[0][0][0][0], outputHandle.get());
2525
2526     return ret;
2527 }
2528
2529
2530 template<armnn::DataType ArmnnType, typename T>
2531 LayerTestResult<T, 4> ResizeBilinearNopTest(
2532         armnn::IWorkloadFactory& workloadFactory,
2533         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
2534         const armnn::DataLayout dataLayout)
2535 {
2536     armnn::TensorInfo inputTensorInfo = armnn::IsQuantizedType<T>()
2537                                         ?  armnnUtils::GetTensorInfo(1, 1, 4, 4, dataLayout, ArmnnType)
2538                                         :  armnnUtils::GetTensorInfo(1, 2, 4, 4, dataLayout, ArmnnType);
2539     armnn::TensorInfo outputTensorInfo = armnn::IsQuantizedType<T>()
2540                                          ?  armnnUtils::GetTensorInfo(1, 1, 4, 4, dataLayout, ArmnnType)
2541                                          :  armnnUtils::GetTensorInfo(1, 2, 4, 4, dataLayout, ArmnnType);
2542     if (armnn::IsQuantizedType<T>())
2543     {
2544         inputTensorInfo.SetQuantizationScale(1.5f);
2545         inputTensorInfo.SetQuantizationOffset(-3);
2546         outputTensorInfo.SetQuantizationScale(1.5f);
2547         outputTensorInfo.SetQuantizationOffset(-3);
2548     }
2549
2550     std::vector<float> inputData = armnn::IsQuantizedType<T>()
2551                                    ? std::initializer_list<float>
2552                                      {
2553                                              1, 2, 3, 4,
2554                                              2, 3, 4, 5,
2555                                              3, 4, 5, 6,
2556                                              4, 5, 6, 7
2557                                      }
2558                                    : std::initializer_list<float>
2559                                      {
2560                                              1.0f, 2.0f, 3.0f, 4.0f,
2561                                              2.0f, 3.0f, 4.0f, 5.0f,
2562                                              3.0f, 4.0f, 5.0f, 6.0f,
2563                                              4.0f, 5.0f, 6.0f, 7.0f,
2564
2565                                              1.0f, 2.0f, 3.0f, 4.0f,
2566                                              2.0f, 3.0f, 4.0f, 5.0f,
2567                                              3.0f, 4.0f, 5.0f, 6.0f,
2568                                              4.0f, 5.0f, 6.0f, 7.0f
2569                                      };
2570
2571     const armnn::PermutationVector NCHWToNHWC = { 0, 3, 1, 2 };
2572     if (dataLayout == armnn::DataLayout::NHWC)
2573     {
2574         std::vector<float> tmp(inputData.size());
2575         armnnUtils::Permute(inputTensorInfo.GetShape(), NCHWToNHWC, inputData.data(), tmp.data(), sizeof(float));
2576         inputData = tmp;
2577     }
2578
2579     auto input = MakeTensor<T, 4>(inputTensorInfo, QuantizedVector<T>(inputTensorInfo.GetQuantizationScale(),
2580                                                                       inputTensorInfo.GetQuantizationOffset(),
2581                                                                       inputData));
2582
2583     LayerTestResult<T, 4> result(outputTensorInfo);
2584     result.outputExpected = input;
2585
2586     std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
2587     std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
2588
2589     armnn::ResizeQueueDescriptor descriptor;
2590     descriptor.m_Parameters.m_Method     = armnn::ResizeMethod::Bilinear;
2591     descriptor.m_Parameters.m_DataLayout = dataLayout;
2592
2593     armnn::WorkloadInfo info;
2594     AddInputToWorkload(descriptor, info, inputTensorInfo, inputHandle.get());
2595     AddOutputToWorkload(descriptor, info, outputTensorInfo, outputHandle.get());
2596
2597     std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateResize(descriptor, info);
2598
2599     inputHandle->Allocate();
2600     outputHandle->Allocate();
2601     CopyDataToITensorHandle(inputHandle.get(), &input[0][0][0][0]);
2602
2603     workload->PostAllocationConfigure();
2604     workload->Execute();
2605
2606     CopyDataFromITensorHandle(&result.output[0][0][0][0], outputHandle.get());
2607     return result;
2608 }
2609
2610 template<armnn::DataType ArmnnType, typename T>
2611 LayerTestResult<T, 4> SimpleResizeBilinearTest(
2612         armnn::IWorkloadFactory& workloadFactory,
2613         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
2614         const armnn::DataLayout dataLayout)
2615 {
2616     armnn::TensorInfo inputTensorInfo = armnn::IsQuantizedType<T>()
2617                                         ?  armnnUtils::GetTensorInfo(1, 1, 2, 2, dataLayout, ArmnnType)
2618                                         :  armnnUtils::GetTensorInfo(1, 2, 2, 2, dataLayout, ArmnnType);
2619     armnn::TensorInfo outputTensorInfo = armnn::IsQuantizedType<T>()
2620                                          ?  armnnUtils::GetTensorInfo(1, 1, 1, 1, dataLayout, ArmnnType)
2621                                          :  armnnUtils::GetTensorInfo(1, 2, 1, 1, dataLayout, ArmnnType);
2622
2623     if (armnn::IsQuantizedType<T>())
2624     {
2625         inputTensorInfo.SetQuantizationScale(0.1567f);
2626         inputTensorInfo.SetQuantizationOffset(1);
2627         outputTensorInfo.SetQuantizationScale(0.1567f);
2628         outputTensorInfo.SetQuantizationOffset(1);
2629     }
2630
2631     std::vector<float> inputData = armnn::IsQuantizedType<T>()
2632                                    ? std::initializer_list<float>
2633                                      {
2634                                              1, 255,
2635                                              200, 250
2636                                      }
2637                                    : std::initializer_list<float>
2638                                      {
2639                                              1.0f, 255.0f,
2640                                              200.0f, 250.0f,
2641
2642                                              250.0f, 200.0f,
2643                                              250.0f,   1.0f
2644                                      };
2645
2646     // The 'resize bilinear' operation projects the top-left corner of output texels into the input image,
2647     // then figures out the interpolants and weights. Note this is different to projecting the centre of the
2648     // output texel. Thus, for a input matrix of 2x2, we'll expect the output 1x1 matrix to contain, as
2649     // its single element, the value that was at position (0,0) of the input matrix (rather than an average,
2650     // which we would expect if projecting the centre).
2651
2652     std::vector<float> outputData = armnn::IsQuantizedType<T>()
2653                                     ? std::initializer_list<float>
2654                                       {
2655                                               1
2656                                       }
2657                                     : std::initializer_list<float>
2658                                       {
2659                                               1.0f,
2660
2661                                               250.0f
2662                                       };
2663
2664     const armnn::PermutationVector NCHWToNHWC = { 0, 3, 1, 2 };
2665     if (dataLayout == armnn::DataLayout::NHWC)
2666     {
2667         std::vector<float> tmp(inputData.size());
2668         armnnUtils::Permute(inputTensorInfo.GetShape(), NCHWToNHWC, inputData.data(), tmp.data(), sizeof(float));
2669         inputData = tmp;
2670
2671         std::vector<float> tmp1(outputData.size());
2672         armnnUtils::Permute(outputTensorInfo.GetShape(), NCHWToNHWC, outputData.data(), tmp1.data(), sizeof(float));
2673         outputData = tmp1;
2674     }
2675
2676     auto input = MakeTensor<T, 4>(inputTensorInfo, QuantizedVector<T>(inputTensorInfo.GetQuantizationScale(),
2677                                                                       inputTensorInfo.GetQuantizationOffset(),
2678                                                                       inputData));
2679
2680     LayerTestResult<T, 4> result(outputTensorInfo);
2681     result.outputExpected = MakeTensor<T, 4>(outputTensorInfo,
2682                                              QuantizedVector<T>(outputTensorInfo.GetQuantizationScale(),
2683                                                                 outputTensorInfo.GetQuantizationOffset(),
2684                                                                 outputData));
2685
2686     std::unique_ptr <armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
2687     std::unique_ptr <armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
2688
2689     armnn::ResizeQueueDescriptor descriptor;
2690     descriptor.m_Parameters.m_Method     = armnn::ResizeMethod::Bilinear;
2691     descriptor.m_Parameters.m_DataLayout = dataLayout;
2692
2693     armnn::WorkloadInfo info;
2694     AddInputToWorkload(descriptor, info, inputTensorInfo, inputHandle.get());
2695     AddOutputToWorkload(descriptor, info, outputTensorInfo, outputHandle.get());
2696
2697     std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateResize(descriptor, info);
2698
2699     inputHandle->Allocate();
2700     outputHandle->Allocate();
2701     CopyDataToITensorHandle(inputHandle.get(), &input[0][0][0][0]);
2702
2703     workload->PostAllocationConfigure();
2704     workload->Execute();
2705
2706     CopyDataFromITensorHandle(&result.output[0][0][0][0], outputHandle.get());
2707     return result;
2708 }
2709
2710 template<armnn::DataType ArmnnType, typename T>
2711 LayerTestResult<T, 4> ResizeBilinearSqMinTest(
2712         armnn::IWorkloadFactory& workloadFactory,
2713         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
2714         const armnn::DataLayout dataLayout)
2715 {
2716     armnn::TensorInfo inputTensorInfo = armnn::IsQuantizedType<T>()
2717                                         ?  armnnUtils::GetTensorInfo(1, 1, 4, 4, dataLayout, ArmnnType)
2718                                         :  armnnUtils::GetTensorInfo(1, 2, 4, 4, dataLayout, ArmnnType);
2719     armnn::TensorInfo outputTensorInfo = armnn::IsQuantizedType<T>()
2720                                          ?  armnnUtils::GetTensorInfo(1, 1, 2, 2, dataLayout, ArmnnType)
2721                                          :  armnnUtils::GetTensorInfo(1, 2, 2, 2, dataLayout, ArmnnType);
2722
2723     if (armnn::IsQuantizedType<T>())
2724     {
2725         inputTensorInfo.SetQuantizationScale(3.141592f);
2726         inputTensorInfo.SetQuantizationOffset(3);
2727         outputTensorInfo.SetQuantizationScale(3.141592f);
2728         outputTensorInfo.SetQuantizationOffset(3);
2729     }
2730
2731         std::vector<float> inputData = armnn::IsQuantizedType<T>()
2732                                        ? std::initializer_list<float>
2733                                          {
2734                                                 1, 2, 3, 4,
2735                                                 2, 3, 4, 5,
2736                                                 3, 4, 5, 6,
2737                                                 4, 5, 6, 7
2738                                          }
2739                                        : std::initializer_list<float>
2740                                          {
2741                                                 1.0f, 2.0f, 3.0f, 4.0f,
2742                                                 2.0f, 3.0f, 4.0f, 5.0f,
2743                                                 3.0f, 4.0f, 5.0f, 6.0f,
2744                                                 4.0f, 5.0f, 6.0f, 7.0f,
2745
2746                                                 7.0f, 6.0f, 5.0f, 4.0f,
2747                                                 6.0f, 5.0f, 4.0f, 3.0f,
2748                                                 5.0f, 4.0f, 3.0f, 2.0f,
2749                                                 4.0f, 3.0f, 2.0f, 1.0f
2750                                          };
2751
2752     std::vector<float> outputData = armnn::IsQuantizedType<T>()
2753                                     ? std::initializer_list<float>
2754                                       {
2755                                               1, 3,
2756                                               3, 5
2757                                       }
2758                                     : std::initializer_list<float>
2759                                       {
2760                                               1.0f, 3.0f,
2761                                               3.0f, 5.0f,
2762
2763                                               7.0f, 5.0f,
2764                                               5.0f, 3.0f
2765                                       };
2766
2767     const armnn::PermutationVector NCHWToNHWC = { 0, 3, 1, 2 };
2768     if (dataLayout == armnn::DataLayout::NHWC)
2769     {
2770         std::vector<float> tmp(inputData.size());
2771         armnnUtils::Permute(inputTensorInfo.GetShape(), NCHWToNHWC, inputData.data(), tmp.data(), sizeof(float));
2772         inputData = tmp;
2773
2774         std::vector<float> tmp1(outputData.size());
2775         armnnUtils::Permute(outputTensorInfo.GetShape(), NCHWToNHWC, outputData.data(), tmp1.data(), sizeof(float));
2776         outputData = tmp1;
2777     }
2778
2779     auto input = MakeTensor<T, 4>(inputTensorInfo, QuantizedVector<T>(inputTensorInfo.GetQuantizationScale(),
2780                                                                       inputTensorInfo.GetQuantizationOffset(),
2781                                                                       inputData));
2782
2783     LayerTestResult<T, 4> result(outputTensorInfo);
2784     result.outputExpected = MakeTensor<T, 4>(outputTensorInfo,
2785                                              QuantizedVector<T>(outputTensorInfo.GetQuantizationScale(),
2786                                                                 outputTensorInfo.GetQuantizationOffset(),
2787                                                                 outputData));
2788
2789     std::unique_ptr <armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
2790     std::unique_ptr <armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
2791
2792     armnn::ResizeQueueDescriptor descriptor;
2793     descriptor.m_Parameters.m_Method     = armnn::ResizeMethod::Bilinear;
2794     descriptor.m_Parameters.m_DataLayout = dataLayout;
2795
2796     armnn::WorkloadInfo info;
2797     AddInputToWorkload(descriptor, info, inputTensorInfo, inputHandle.get());
2798     AddOutputToWorkload(descriptor, info, outputTensorInfo, outputHandle.get());
2799
2800     std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateResize(descriptor, info);
2801
2802     inputHandle->Allocate();
2803     outputHandle->Allocate();
2804     CopyDataToITensorHandle(inputHandle.get(), &input[0][0][0][0]);
2805
2806     workload->PostAllocationConfigure();
2807     workload->Execute();
2808
2809     CopyDataFromITensorHandle(&result.output[0][0][0][0], outputHandle.get());
2810     return result;
2811 }
2812
2813 template<armnn::DataType ArmnnType, typename T>
2814 LayerTestResult<T, 4> ResizeBilinearMinTest(
2815         armnn::IWorkloadFactory& workloadFactory,
2816         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
2817         const armnn::DataLayout dataLayout)
2818 {
2819     armnn::TensorInfo inputTensorInfo = armnn::IsQuantizedType<T>()
2820                                         ?  armnnUtils::GetTensorInfo(1, 1, 2, 3, dataLayout, ArmnnType)
2821                                         :  armnnUtils::GetTensorInfo(1, 2, 3, 5, dataLayout, ArmnnType);
2822     armnn::TensorInfo outputTensorInfo = armnn::IsQuantizedType<T>()
2823                                          ?  armnnUtils::GetTensorInfo(1, 1, 1, 2, dataLayout, ArmnnType)
2824                                          :  armnnUtils::GetTensorInfo(1, 2, 2, 3, dataLayout, ArmnnType);
2825
2826     if (armnn::IsQuantizedType<T>())
2827     {
2828         inputTensorInfo.SetQuantizationScale(1.5f);
2829         inputTensorInfo.SetQuantizationOffset(-1);
2830         outputTensorInfo.SetQuantizationScale(1.5f);
2831         outputTensorInfo.SetQuantizationOffset(-1);
2832     }
2833
2834     std::vector<float> inputData = armnn::IsQuantizedType<T>()
2835                                    ? std::initializer_list<float>
2836                                      {
2837                                              3.0f, 4.5f, 6.0f, // 1,  2,  3, : Expected quantised values
2838                                              9.0f, 13.5f, 21.0f // 5,  8, 13
2839                                      }
2840                                    : std::initializer_list<float>
2841                                      {
2842                                              1.0f, 2.0f, 3.0f, 5.0f, 8.0f,
2843                                              13.0f, 21.0f, 34.0f, 55.0f, 89.0f,
2844                                              144.0f, 233.0f, 377.0f, 610.0f, 987.0f,
2845
2846                                              987.0f, 610.0f, 377.0f, 233.0f, 144.0f,
2847                                              89.0f, 55.0f, 34.0f, 21.0f, 13.0f,
2848                                              8.0f, 5.0f, 3.0f, 2.0f, 1.0f
2849                                      };
2850
2851     std::vector<float> outputData = armnn::IsQuantizedType<T>()
2852                                     ? std::initializer_list<float>
2853                                       {
2854                                               3.0f, 5.25f // 1, 3
2855                                       }
2856                                     : std::initializer_list<float>
2857                                       {
2858                                               1.0f,   2.6666f,   6.00f,
2859                                               78.5f, 179.3333f, 401.00f,
2860
2861                                               987.0f, 454.6670f, 203.33f,
2862                                               48.5f,  22.3333f,  10.00f
2863                                       };
2864
2865     const armnn::PermutationVector NCHWToNHWC = { 0, 3, 1, 2 };
2866     if (dataLayout == armnn::DataLayout::NHWC)
2867     {
2868         std::vector<float> tmp(inputData.size());
2869         armnnUtils::Permute(inputTensorInfo.GetShape(), NCHWToNHWC, inputData.data(), tmp.data(), sizeof(float));
2870         inputData = tmp;
2871
2872         std::vector<float> tmp1(outputData.size());
2873         armnnUtils::Permute(outputTensorInfo.GetShape(), NCHWToNHWC, outputData.data(), tmp1.data(), sizeof(float));
2874         outputData = tmp1;
2875     }
2876
2877     auto input = MakeTensor<T, 4>(inputTensorInfo, QuantizedVector<T>(inputTensorInfo.GetQuantizationScale(),
2878                                                                       inputTensorInfo.GetQuantizationOffset(),
2879                                                                       inputData));
2880
2881     LayerTestResult<T, 4> result(outputTensorInfo);
2882     result.outputExpected = MakeTensor<T, 4>(outputTensorInfo,
2883                                              QuantizedVector<T>(outputTensorInfo.GetQuantizationScale(),
2884                                                                 outputTensorInfo.GetQuantizationOffset(),
2885                                                                 outputData));
2886
2887     std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
2888     std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
2889
2890     armnn::ResizeQueueDescriptor descriptor;
2891     descriptor.m_Parameters.m_Method     = armnn::ResizeMethod::Bilinear;
2892     descriptor.m_Parameters.m_DataLayout = dataLayout;
2893
2894     armnn::WorkloadInfo info;
2895     AddInputToWorkload(descriptor, info, inputTensorInfo, inputHandle.get());
2896     AddOutputToWorkload(descriptor, info, outputTensorInfo, outputHandle.get());
2897
2898     std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateResize(descriptor, info);
2899
2900     inputHandle->Allocate();
2901     outputHandle->Allocate();
2902     CopyDataToITensorHandle(inputHandle.get(), &input[0][0][0][0]);
2903
2904     workload->PostAllocationConfigure();
2905     workload->Execute();
2906
2907     CopyDataFromITensorHandle(&result.output[0][0][0][0], outputHandle.get());
2908     return result;
2909 }
2910
2911 template<armnn::DataType ArmnnType, typename T>
2912 LayerTestResult<T, 4> ResizeBilinearMagTest(
2913         armnn::IWorkloadFactory& workloadFactory,
2914         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
2915         const armnn::DataLayout dataLayout)
2916 {
2917     armnn::TensorInfo inputTensorInfo = armnn::IsQuantizedType<T>()
2918                                         ?  armnnUtils::GetTensorInfo(1, 1, 3, 2, dataLayout, ArmnnType)
2919                                         :  armnnUtils::GetTensorInfo(1, 2, 3, 2, dataLayout, ArmnnType);
2920     armnn::TensorInfo outputTensorInfo = armnn::IsQuantizedType<T>()
2921                                          ?  armnnUtils::GetTensorInfo(1, 1, 3, 5, dataLayout, ArmnnType)
2922                                          :  armnnUtils::GetTensorInfo(1, 2, 3, 5, dataLayout, ArmnnType);
2923
2924     if (armnn::IsQuantizedType<T>())
2925     {
2926         inputTensorInfo.SetQuantizationScale(0.010765f);
2927         inputTensorInfo.SetQuantizationOffset(7);
2928         outputTensorInfo.SetQuantizationScale(0.010132f);
2929         outputTensorInfo.SetQuantizationOffset(-18);
2930     }
2931
2932     std::vector<float> inputData = armnn::IsQuantizedType<T>()
2933                                    ? std::initializer_list<float>
2934                                      {
2935                                              0.183005f, 2.379065f, // 24, 228, : Expected quantised values
2936                                              1.05497f, 1.302565f, // 105, 128,
2937                                              2.400595f, 0.68896f // 230, 71
2938                                      }
2939                                    : std::initializer_list<float>
2940                                      {
2941                                              1.0f,   2.0f,
2942                                              13.0f,  21.0f,
2943                                              144.0f, 233.0f,
2944
2945                                              233.0f, 144.0f,
2946                                              21.0f,  13.0f,
2947                                              2.0f,   1.0f
2948                                      };
2949     std::vector<float> outputData = armnn::IsQuantizedType<T>()
2950                                     ? std::initializer_list<float>
2951                                       {
2952                                               0.18300501f, 1.06142902f, 1.93985295f, 2.37906504f, 2.37906504f,
2953                                               1.05497003f, 1.15400803f, 1.25304604f, 1.30256498f, 1.30256498f,
2954                                               2.40059495f, 1.71594095f, 1.03128707f, 0.68896002f, 0.68896002f
2955                                               // 0, 87, 173, 217, 217, : Expected quantised values
2956                                               // 86, 96, 106, 111, 111,
2957                                               // 219, 151, 84, 50, 50
2958                                       }
2959                                     : std::initializer_list<float>
2960                                       {
2961                                               1.0f,   1.4f,   1.8f,   2.0f,   2.0f,
2962                                               13.0f,  16.2f,  19.4f,  21.0f,  21.0f,
2963                                               144.0f, 179.6f, 215.2f, 233.0f, 233.0f,
2964
2965                                               233.0f, 197.4f, 161.8f, 144.0f, 144.0f,
2966                                               21.0f,  17.8f,  14.6f,  13.0f,  13.0f,
2967                                               2.0f,   1.6f,   1.2f,   1.0f,   1.0f
2968                                       };
2969
2970     const armnn::PermutationVector NCHWToNHWC = { 0, 3, 1, 2 };
2971     if (dataLayout == armnn::DataLayout::NHWC)
2972     {
2973         std::vector<float> tmp(inputData.size());
2974         armnnUtils::Permute(inputTensorInfo.GetShape(), NCHWToNHWC, inputData.data(), tmp.data(), sizeof(float));
2975         inputData = tmp;
2976
2977         std::vector<float> tmp1(outputData.size());
2978         armnnUtils::Permute(outputTensorInfo.GetShape(), NCHWToNHWC, outputData.data(), tmp1.data(), sizeof(float));
2979         outputData = tmp1;
2980     }
2981
2982     auto input = MakeTensor<T, 4>(inputTensorInfo, QuantizedVector<T>(inputTensorInfo.GetQuantizationScale(),
2983                                                                       inputTensorInfo.GetQuantizationOffset(),
2984                                                                       inputData));
2985
2986     LayerTestResult<T, 4> result(outputTensorInfo);
2987     result.outputExpected = MakeTensor<T, 4>(outputTensorInfo,
2988                                              QuantizedVector<T>(outputTensorInfo.GetQuantizationScale(),
2989                                                                 outputTensorInfo.GetQuantizationOffset(),
2990                                                                 outputData));
2991
2992     std::unique_ptr <armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
2993     std::unique_ptr <armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
2994
2995     armnn::ResizeQueueDescriptor descriptor;
2996     descriptor.m_Parameters.m_Method     = armnn::ResizeMethod::Bilinear;
2997     descriptor.m_Parameters.m_DataLayout = dataLayout;
2998
2999     armnn::WorkloadInfo info;
3000     AddInputToWorkload(descriptor, info, inputTensorInfo, inputHandle.get());
3001     AddOutputToWorkload(descriptor, info, outputTensorInfo, outputHandle.get());
3002
3003     std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateResize(descriptor, info);
3004
3005     inputHandle->Allocate();
3006     outputHandle->Allocate();
3007     CopyDataToITensorHandle(inputHandle.get(), &input[0][0][0][0]);
3008
3009     workload->PostAllocationConfigure();
3010     workload->Execute();
3011
3012     CopyDataFromITensorHandle(&result.output[0][0][0][0], outputHandle.get());
3013     return result;
3014 }
3015
3016
3017 template<armnn::DataType ArmnnType, typename T>
3018 LayerTestResult<T, 4> ResizeNearestNeighborNopTest(
3019         armnn::IWorkloadFactory& workloadFactory,
3020         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
3021         const armnn::DataLayout dataLayout)
3022 {
3023     armnn::TensorInfo inputTensorInfo = armnn::IsQuantizedType<T>()
3024                                         ?  armnnUtils::GetTensorInfo(1, 1, 4, 4, dataLayout, ArmnnType)
3025                                         :  armnnUtils::GetTensorInfo(1, 2, 4, 4, dataLayout, ArmnnType);
3026     armnn::TensorInfo outputTensorInfo = armnn::IsQuantizedType<T>()
3027                                          ?  armnnUtils::GetTensorInfo(1, 1, 4, 4, dataLayout, ArmnnType)
3028                                          :  armnnUtils::GetTensorInfo(1, 2, 4, 4, dataLayout, ArmnnType);
3029     if (armnn::IsQuantizedType<T>())
3030     {
3031         inputTensorInfo.SetQuantizationScale(1.5f);
3032         inputTensorInfo.SetQuantizationOffset(-3);
3033         outputTensorInfo.SetQuantizationScale(1.5f);
3034         outputTensorInfo.SetQuantizationOffset(-3);
3035     }
3036
3037     std::vector<float> inputData = armnn::IsQuantizedType<T>()
3038                                    ? std::initializer_list<float>
3039                                            {
3040                                                    1, 2, 3, 4,
3041                                                    2, 3, 4, 5,
3042                                                    3, 4, 5, 6,
3043                                                    4, 5, 6, 7
3044                                            }
3045                                    : std::initializer_list<float>
3046                                            {
3047                                                    1.0f, 2.0f, 3.0f, 4.0f,
3048                                                    2.0f, 3.0f, 4.0f, 5.0f,
3049                                                    3.0f, 4.0f, 5.0f, 6.0f,
3050                                                    4.0f, 5.0f, 6.0f, 7.0f,
3051
3052                                                    1.0f, 2.0f, 3.0f, 4.0f,
3053                                                    2.0f, 3.0f, 4.0f, 5.0f,
3054                                                    3.0f, 4.0f, 5.0f, 6.0f,
3055                                                    4.0f, 5.0f, 6.0f, 7.0f
3056                                            };
3057
3058     const armnn::PermutationVector NCHWToNHWC = { 0, 3, 1, 2 };
3059     if (dataLayout == armnn::DataLayout::NHWC)
3060     {
3061         std::vector<float> tmp(inputData.size());
3062         armnnUtils::Permute(inputTensorInfo.GetShape(), NCHWToNHWC, inputData.data(), tmp.data(), sizeof(float));
3063         inputData = tmp;
3064     }
3065
3066     auto input = MakeTensor<T, 4>(inputTensorInfo, QuantizedVector<T>(inputTensorInfo.GetQuantizationScale(),
3067                                                                       inputTensorInfo.GetQuantizationOffset(),
3068                                                                       inputData));
3069
3070     LayerTestResult<T, 4> result(outputTensorInfo);
3071     result.outputExpected = input;
3072
3073     std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
3074     std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
3075
3076     armnn::ResizeQueueDescriptor descriptor;
3077     descriptor.m_Parameters.m_Method = armnn::ResizeMethod::NearestNeighbor;
3078     descriptor.m_Parameters.m_DataLayout = dataLayout;
3079     armnn::WorkloadInfo info;
3080     AddInputToWorkload(descriptor, info, inputTensorInfo, inputHandle.get());
3081     AddOutputToWorkload(descriptor, info, outputTensorInfo, outputHandle.get());
3082
3083     std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateResize(descriptor, info);
3084
3085     inputHandle->Allocate();
3086     outputHandle->Allocate();
3087     CopyDataToITensorHandle(inputHandle.get(), &input[0][0][0][0]);
3088
3089     workload->PostAllocationConfigure();
3090     workload->Execute();
3091
3092     CopyDataFromITensorHandle(&result.output[0][0][0][0], outputHandle.get());
3093     return result;
3094 }
3095
3096 template<armnn::DataType ArmnnType, typename T>
3097 LayerTestResult<T, 4> SimpleResizeNearestNeighborTest(
3098         armnn::IWorkloadFactory& workloadFactory,
3099         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
3100         const armnn::DataLayout dataLayout)
3101 {
3102     armnn::TensorInfo inputTensorInfo = armnn::IsQuantizedType<T>()
3103                                         ?  armnnUtils::GetTensorInfo(1, 1, 2, 2, dataLayout, ArmnnType)
3104                                         :  armnnUtils::GetTensorInfo(1, 2, 2, 2, dataLayout, ArmnnType);
3105     armnn::TensorInfo outputTensorInfo = armnn::IsQuantizedType<T>()
3106                                          ?  armnnUtils::GetTensorInfo(1, 1, 1, 1, dataLayout, ArmnnType)
3107                                          :  armnnUtils::GetTensorInfo(1, 2, 1, 1, dataLayout, ArmnnType);
3108
3109     if (armnn::IsQuantizedType<T>())
3110     {
3111         inputTensorInfo.SetQuantizationScale(0.1567f);
3112         inputTensorInfo.SetQuantizationOffset(1);
3113         outputTensorInfo.SetQuantizationScale(0.1567f);
3114         outputTensorInfo.SetQuantizationOffset(1);
3115     }
3116
3117     std::vector<float> inputData = armnn::IsQuantizedType<T>()
3118                                    ? std::initializer_list<float>
3119                                            {
3120                                                    1, 255,
3121                                                    200, 250
3122                                            }
3123                                    : std::initializer_list<float>
3124                                            {
3125                                                    1.0f, 255.0f,
3126                                                    200.0f, 250.0f,
3127
3128                                                    250.0f, 200.0f,
3129                                                    250.0f,   1.0f
3130                                            };
3131
3132     // The 'resize' operation projects the top-left corner of output texels into the input image,
3133     // then figures out the interpolants and weights. Note this is different to projecting the centre of the
3134     // output texel. Thus, for a input matrix of 2x2, we'll expect the output 1x1 matrix to contain, as
3135     // its single element, the value that was at position (0,0) of the input matrix (rather than an average,
3136     // which we would expect if projecting the centre).
3137
3138     std::vector<float> outputData = armnn::IsQuantizedType<T>()
3139                                     ? std::initializer_list<float>
3140                                             {
3141                                                     1
3142                                             }
3143                                     : std::initializer_list<float>
3144                                             {
3145                                                     1.0f,
3146
3147                                                     250.0f
3148                                             };
3149
3150     const armnn::PermutationVector NCHWToNHWC = { 0, 3, 1, 2 };
3151     if (dataLayout == armnn::DataLayout::NHWC)
3152     {
3153         std::vector<float> tmp(inputData.size());
3154         armnnUtils::Permute(inputTensorInfo.GetShape(), NCHWToNHWC, inputData.data(), tmp.data(), sizeof(float));
3155         inputData = tmp;
3156
3157         std::vector<float> tmp1(outputData.size());
3158         armnnUtils::Permute(outputTensorInfo.GetShape(), NCHWToNHWC, outputData.data(), tmp1.data(), sizeof(float));
3159         outputData = tmp1;
3160     }
3161
3162     auto input = MakeTensor<T, 4>(inputTensorInfo, QuantizedVector<T>(inputTensorInfo.GetQuantizationScale(),
3163                                                                       inputTensorInfo.GetQuantizationOffset(),
3164                                                                       inputData));
3165
3166     LayerTestResult<T, 4> result(outputTensorInfo);
3167     result.outputExpected = MakeTensor<T, 4>(outputTensorInfo,
3168                                              QuantizedVector<T>(outputTensorInfo.GetQuantizationScale(),
3169                                                                 outputTensorInfo.GetQuantizationOffset(),
3170                                                                 outputData));
3171
3172     std::unique_ptr <armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
3173     std::unique_ptr <armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
3174
3175     armnn::ResizeQueueDescriptor descriptor;
3176     descriptor.m_Parameters.m_DataLayout = dataLayout;
3177     descriptor.m_Parameters.m_Method = armnn::ResizeMethod::NearestNeighbor;
3178     armnn::WorkloadInfo info;
3179     AddInputToWorkload(descriptor, info, inputTensorInfo, inputHandle.get());
3180     AddOutputToWorkload(descriptor, info, outputTensorInfo, outputHandle.get());
3181
3182     std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateResize(descriptor, info);
3183
3184     inputHandle->Allocate();
3185     outputHandle->Allocate();
3186     CopyDataToITensorHandle(inputHandle.get(), &input[0][0][0][0]);
3187
3188     workload->PostAllocationConfigure();
3189     workload->Execute();
3190
3191     CopyDataFromITensorHandle(&result.output[0][0][0][0], outputHandle.get());
3192     return result;
3193 }
3194
3195 template<armnn::DataType ArmnnType, typename T>
3196 LayerTestResult<T, 4> ResizeNearestNeighborSqMinTest(
3197         armnn::IWorkloadFactory& workloadFactory,
3198         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
3199         const armnn::DataLayout dataLayout)
3200 {
3201     armnn::TensorInfo inputTensorInfo = armnn::IsQuantizedType<T>()
3202                                         ?  armnnUtils::GetTensorInfo(1, 1, 4, 4, dataLayout, ArmnnType)
3203                                         :  armnnUtils::GetTensorInfo(1, 2, 4, 4, dataLayout, ArmnnType);
3204     armnn::TensorInfo outputTensorInfo = armnn::IsQuantizedType<T>()
3205                                          ?  armnnUtils::GetTensorInfo(1, 1, 2, 2, dataLayout, ArmnnType)
3206                                          :  armnnUtils::GetTensorInfo(1, 2, 2, 2, dataLayout, ArmnnType);
3207
3208     if (armnn::IsQuantizedType<T>())
3209     {
3210         inputTensorInfo.SetQuantizationScale(3.141592f);
3211         inputTensorInfo.SetQuantizationOffset(3);
3212         outputTensorInfo.SetQuantizationScale(3.141592f);
3213         outputTensorInfo.SetQuantizationOffset(3);
3214     }
3215
3216     std::vector<float> inputData = armnn::IsQuantizedType<T>()
3217                                    ? std::initializer_list<float>
3218                                            {
3219                                                   1, 2, 3, 4,
3220                                                   2, 3, 4, 5,
3221                                                   3, 4, 5, 6,
3222                                                   4, 5, 6, 7
3223                                            }
3224                                    : std::initializer_list<float>
3225                                            {
3226                                                    1.0f, 2.0f, 3.0f, 4.0f,
3227                                                    2.0f, 3.0f, 4.0f, 5.0f,
3228                                                    3.0f, 4.0f, 5.0f, 6.0f,
3229                                                    4.0f, 5.0f, 6.0f, 7.0f,
3230
3231                                                    7.0f, 6.0f, 5.0f, 4.0f,
3232                                                    6.0f, 5.0f, 4.0f, 3.0f,
3233                                                    5.0f, 4.0f, 3.0f, 2.0f,
3234                                                    4.0f, 3.0f, 2.0f, 1.0f
3235                                            };
3236
3237     std::vector<float> outputData = armnn::IsQuantizedType<T>()
3238                                     ? std::initializer_list<float>
3239                                             {
3240                                                     1, 3,
3241                                                     3, 5
3242                                             }
3243                                     : std::initializer_list<float>
3244                                             {
3245                                                     1.0f, 3.0f,
3246                                                     3.0f, 5.0f,
3247
3248                                                     7.0f, 5.0f,
3249                                                     5.0f, 3.0f
3250                                             };
3251
3252     const armnn::PermutationVector NCHWToNHWC = { 0, 3, 1, 2 };
3253     if (dataLayout == armnn::DataLayout::NHWC)
3254     {
3255         std::vector<float> tmp(inputData.size());
3256         armnnUtils::Permute(inputTensorInfo.GetShape(), NCHWToNHWC, inputData.data(), tmp.data(), sizeof(float));
3257         inputData = tmp;
3258
3259         std::vector<float> tmp1(outputData.size());
3260         armnnUtils::Permute(outputTensorInfo.GetShape(), NCHWToNHWC, outputData.data(), tmp1.data(), sizeof(float));
3261         outputData = tmp1;
3262     }
3263
3264     auto input = MakeTensor<T, 4>(inputTensorInfo, QuantizedVector<T>(inputTensorInfo.GetQuantizationScale(),
3265                                                                       inputTensorInfo.GetQuantizationOffset(),
3266                                                                       inputData));
3267
3268     LayerTestResult<T, 4> result(outputTensorInfo);
3269     result.outputExpected = MakeTensor<T, 4>(outputTensorInfo,
3270                                              QuantizedVector<T>(outputTensorInfo.GetQuantizationScale(),
3271                                                                 outputTensorInfo.GetQuantizationOffset(),
3272                                                                 outputData));
3273
3274     std::unique_ptr <armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
3275     std::unique_ptr <armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
3276
3277     armnn::ResizeQueueDescriptor descriptor;
3278     descriptor.m_Parameters.m_DataLayout = dataLayout;
3279     descriptor.m_Parameters.m_Method = armnn::ResizeMethod::NearestNeighbor;
3280     armnn::WorkloadInfo info;
3281     AddInputToWorkload(descriptor, info, inputTensorInfo, inputHandle.get());
3282     AddOutputToWorkload(descriptor, info, outputTensorInfo, outputHandle.get());
3283
3284     std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateResize(descriptor, info);
3285
3286     inputHandle->Allocate();
3287     outputHandle->Allocate();
3288     CopyDataToITensorHandle(inputHandle.get(), &input[0][0][0][0]);
3289
3290     workload->PostAllocationConfigure();
3291     workload->Execute();
3292
3293     CopyDataFromITensorHandle(&result.output[0][0][0][0], outputHandle.get());
3294     return result;
3295 }
3296
3297 template<armnn::DataType ArmnnType, typename T>
3298 LayerTestResult<T, 4> ResizeNearestNeighborMinTest(
3299         armnn::IWorkloadFactory& workloadFactory,
3300         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
3301         const armnn::DataLayout dataLayout)
3302 {
3303     armnn::TensorInfo inputTensorInfo = armnn::IsQuantizedType<T>()
3304                                         ?  armnnUtils::GetTensorInfo(1, 1, 2, 3, dataLayout, ArmnnType)
3305                                         :  armnnUtils::GetTensorInfo(1, 2, 3, 5, dataLayout, ArmnnType);
3306     armnn::TensorInfo outputTensorInfo = armnn::IsQuantizedType<T>()
3307                                          ?  armnnUtils::GetTensorInfo(1, 1, 1, 2, dataLayout, ArmnnType)
3308                                          :  armnnUtils::GetTensorInfo(1, 2, 2, 3, dataLayout, ArmnnType);
3309
3310     if (armnn::IsQuantizedType<T>())
3311     {
3312         inputTensorInfo.SetQuantizationScale(1.5f);
3313         inputTensorInfo.SetQuantizationOffset(-1);
3314         outputTensorInfo.SetQuantizationScale(1.5f);
3315         outputTensorInfo.SetQuantizationOffset(-1);
3316     }
3317
3318     std::vector<float> inputData = armnn::IsQuantizedType<T>()
3319                                    ? std::initializer_list<float>
3320                                            {
3321                                                    3.0f, 4.5f, 6.0f, // 1,  2,  3, : Expected quantised values
3322                                                    9.0f, 13.5f, 21.0f // 5,  8, 13
3323                                            }
3324                                    : std::initializer_list<float>
3325                                            {
3326                                                    1.0f, 2.0f, 3.0f, 5.0f, 8.0f,
3327                                                    13.0f, 21.0f, 34.0f, 55.0f, 89.0f,
3328                                                    144.0f, 233.0f, 377.0f, 610.0f, 987.0f,
3329
3330                                                    987.0f, 610.0f, 377.0f, 233.0f, 144.0f,
3331                                                    89.0f, 55.0f, 34.0f, 21.0f, 13.0f,
3332                                                    8.0f, 5.0f, 3.0f, 2.0f, 1.0f
3333                                            };
3334
3335     std::vector<float> outputData = armnn::IsQuantizedType<T>()
3336                                     ? std::initializer_list<float>
3337                                             {
3338                                                     3.0f, 4.5f // 1, 3
3339                                             }
3340                                     : std::initializer_list<float>
3341                                             {
3342                                                     1.f,   2.f,   5.f,
3343                                                    13.f,  21.f,  55.f,
3344
3345                                                   987.f, 610.f, 233.f,
3346                                                    89.f,  55.f,  21.f
3347                                             };
3348
3349     const armnn::PermutationVector NCHWToNHWC = { 0, 3, 1, 2 };
3350     if (dataLayout == armnn::DataLayout::NHWC)
3351     {
3352         std::vector<float> tmp(inputData.size());
3353         armnnUtils::Permute(inputTensorInfo.GetShape(), NCHWToNHWC, inputData.data(), tmp.data(), sizeof(float));
3354         inputData = tmp;
3355
3356         std::vector<float> tmp1(outputData.size());
3357         armnnUtils::Permute(outputTensorInfo.GetShape(), NCHWToNHWC, outputData.data(), tmp1.data(), sizeof(float));
3358         outputData = tmp1;
3359     }
3360
3361     auto input = MakeTensor<T, 4>(inputTensorInfo, QuantizedVector<T>(inputTensorInfo.GetQuantizationScale(),
3362                                                                       inputTensorInfo.GetQuantizationOffset(),
3363                                                                       inputData));
3364
3365     LayerTestResult<T, 4> result(outputTensorInfo);
3366     result.outputExpected = MakeTensor<T, 4>(outputTensorInfo,
3367                                              QuantizedVector<T>(outputTensorInfo.GetQuantizationScale(),
3368                                                                 outputTensorInfo.GetQuantizationOffset(),
3369                                                                 outputData));
3370
3371     std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
3372     std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
3373
3374     armnn::ResizeQueueDescriptor descriptor;
3375     descriptor.m_Parameters.m_DataLayout = dataLayout;
3376     descriptor.m_Parameters.m_Method = armnn::ResizeMethod::NearestNeighbor;
3377     armnn::WorkloadInfo info;
3378     AddInputToWorkload(descriptor, info, inputTensorInfo, inputHandle.get());
3379     AddOutputToWorkload(descriptor, info, outputTensorInfo, outputHandle.get());
3380
3381     std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateResize(descriptor, info);
3382
3383     inputHandle->Allocate();
3384     outputHandle->Allocate();
3385     CopyDataToITensorHandle(inputHandle.get(), &input[0][0][0][0]);
3386
3387     workload->PostAllocationConfigure();
3388     workload->Execute();
3389
3390     CopyDataFromITensorHandle(&result.output[0][0][0][0], outputHandle.get());
3391     return result;
3392 }
3393
3394 template<armnn::DataType ArmnnType, typename T>
3395 LayerTestResult<T, 4> ResizeNearestNeighborMagTest(
3396         armnn::IWorkloadFactory& workloadFactory,
3397         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
3398         const armnn::DataLayout dataLayout,
3399         float inQuantScale,
3400         int32_t inQuantOffset,
3401         float outQuantScale,
3402         int32_t outQuantOffset)
3403 {
3404     armnn::TensorInfo inputTensorInfo = armnn::IsQuantizedType<T>()
3405                                         ?  armnnUtils::GetTensorInfo(1, 1, 3, 2, dataLayout, ArmnnType)
3406                                         :  armnnUtils::GetTensorInfo(1, 2, 3, 2, dataLayout, ArmnnType);
3407     armnn::TensorInfo outputTensorInfo = armnn::IsQuantizedType<T>()
3408                                          ?  armnnUtils::GetTensorInfo(1, 1, 3, 5, dataLayout, ArmnnType)
3409                                          :  armnnUtils::GetTensorInfo(1, 2, 3, 5, dataLayout, ArmnnType);
3410
3411     if (armnn::IsQuantizedType<T>())
3412     {
3413         inputTensorInfo.SetQuantizationScale(inQuantScale);
3414         inputTensorInfo.SetQuantizationOffset(inQuantOffset);
3415         outputTensorInfo.SetQuantizationScale(outQuantScale);
3416         outputTensorInfo.SetQuantizationOffset(outQuantOffset);
3417     }
3418
3419     std::vector<float> inputData = armnn::IsQuantizedType<T>()
3420                                    ? std::initializer_list<float>
3421                                         {
3422                                             0.183005f, 2.379065f, //  24, 228, : expected quantised values
3423                                             1.054970f, 1.302565f, // 105, 128,
3424                                             2.400595f, 0.688960f  // 230, 71
3425                                         }
3426                                    : std::initializer_list<float>
3427                                         {
3428                                                1.0f,   2.0f,
3429                                               13.0f,  21.0f,
3430                                             144.0f, 233.0f,
3431
3432                                             233.0f, 144.0f,
3433                                              21.0f,  13.0f,
3434                                               2.0f,   1.0f
3435                                         };
3436     std::vector<float> outputData = armnn::IsQuantizedType<T>()
3437                                     ? std::initializer_list<float>
3438                                         {
3439                                             0.183005f, 0.183005f, 0.183005f, 2.379065f, 2.379065f,
3440                                             1.054970f, 1.054970f, 1.054970f, 1.302565f, 1.302565f,
3441                                             2.400595f, 2.400595f, 2.400595f, 0.688960f, 0.688960f
3442                                         }
3443                                     : std::initializer_list<float>
3444                                         {
3445                                               1.f,   1.f,   1.f,   2.f,   2.f,
3446                                              13.f,  13.f,  13.f,  21.f,  21.f,
3447                                             144.f, 144.f, 144.f, 233.f, 233.f,
3448
3449                                             233.f, 233.f, 233.f, 144.f, 144.f,
3450                                              21.f,  21.f,  21.f,  13.f,  13.f,
3451                                               2.f,   2.f,   2.f,   1.f,   1.f
3452                                         };
3453
3454     const armnn::PermutationVector NCHWToNHWC = { 0, 3, 1, 2 };
3455     if (dataLayout == armnn::DataLayout::NHWC)
3456     {
3457         std::vector<float> tmp(inputData.size());
3458         armnnUtils::Permute(inputTensorInfo.GetShape(), NCHWToNHWC, inputData.data(), tmp.data(), sizeof(float));
3459         inputData = tmp;
3460
3461         std::vector<float> tmp1(outputData.size());
3462         armnnUtils::Permute(outputTensorInfo.GetShape(), NCHWToNHWC, outputData.data(), tmp1.data(), sizeof(float));
3463         outputData = tmp1;
3464     }
3465
3466     auto input = MakeTensor<T, 4>(inputTensorInfo, QuantizedVector<T>(inputTensorInfo.GetQuantizationScale(),
3467                                                                       inputTensorInfo.GetQuantizationOffset(),
3468                                                                       inputData));
3469
3470     LayerTestResult<T, 4> result(outputTensorInfo);
3471     result.outputExpected = MakeTensor<T, 4>(outputTensorInfo,
3472                                              QuantizedVector<T>(outputTensorInfo.GetQuantizationScale(),
3473                                                                 outputTensorInfo.GetQuantizationOffset(),
3474                                                                 outputData));
3475
3476     std::unique_ptr <armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
3477     std::unique_ptr <armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
3478
3479     armnn::ResizeQueueDescriptor descriptor;
3480     descriptor.m_Parameters.m_DataLayout = dataLayout;
3481     descriptor.m_Parameters.m_Method = armnn::ResizeMethod::NearestNeighbor;
3482     armnn::WorkloadInfo info;
3483     AddInputToWorkload(descriptor, info, inputTensorInfo, inputHandle.get());
3484     AddOutputToWorkload(descriptor, info, outputTensorInfo, outputHandle.get());
3485
3486     std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateResize(descriptor, info);
3487
3488     inputHandle->Allocate();
3489     outputHandle->Allocate();
3490     CopyDataToITensorHandle(inputHandle.get(), &input[0][0][0][0]);
3491
3492     workload->PostAllocationConfigure();
3493     workload->Execute();
3494
3495     CopyDataFromITensorHandle(&result.output[0][0][0][0], outputHandle.get());
3496     return result;
3497 }
3498
3499 template<armnn::DataType ArmnnType, typename T, std::size_t InputDim, std::size_t OutputDim>
3500 LayerTestResult<T, OutputDim> MeanTestHelper(
3501         armnn::IWorkloadFactory& workloadFactory,
3502         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
3503         const unsigned int* inputShape,
3504         const std::vector<float>& inputData,
3505         const std::vector<unsigned int>& axis,
3506         bool keepDims,
3507         const unsigned int* outputShape,
3508         const std::vector<float>& outputData,
3509         float scale = 1.0f,
3510         int32_t offset = 0)
3511 {
3512     armnn::TensorInfo inputTensorInfo(InputDim, inputShape, ArmnnType);
3513     armnn::TensorInfo outputTensorInfo(OutputDim, outputShape, ArmnnType);
3514
3515     inputTensorInfo.SetQuantizationScale(scale);
3516     inputTensorInfo.SetQuantizationOffset(offset);
3517
3518     outputTensorInfo.SetQuantizationScale(scale);
3519     outputTensorInfo.SetQuantizationOffset(offset);
3520
3521     auto input = MakeTensor<T, InputDim>(inputTensorInfo, ConvertToDataType<ArmnnType>(inputData, inputTensorInfo));
3522
3523     LayerTestResult<T, OutputDim> result(outputTensorInfo);
3524     result.outputExpected = MakeTensor<T, OutputDim>(
3525             outputTensorInfo, ConvertToDataType<ArmnnType>(outputData, outputTensorInfo));
3526
3527     std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
3528     std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
3529
3530     armnn::MeanQueueDescriptor data;
3531     data.m_Parameters.m_Axis = axis;
3532     data.m_Parameters.m_KeepDims = keepDims;
3533     armnn::WorkloadInfo info;
3534     AddInputToWorkload(data,  info, inputTensorInfo, inputHandle.get());
3535     AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
3536
3537     std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateMean(data, info);
3538
3539     inputHandle->Allocate();
3540     outputHandle->Allocate();
3541
3542     CopyDataToITensorHandle(inputHandle.get(), input.origin());
3543
3544     workload->PostAllocationConfigure();
3545     workload->Execute();
3546
3547     CopyDataFromITensorHandle(result.output.origin(), outputHandle.get());
3548
3549     return result;
3550 }
3551
3552 template<armnn::DataType ArmnnType, typename T>
3553 LayerTestResult<T, 1> MeanSimpleTest(
3554         armnn::IWorkloadFactory& workloadFactory,
3555         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3556 {
3557     const unsigned int inputShape[] = { 3, 2 };
3558     const unsigned int outputShape[] = { 1 };
3559
3560     std::vector<float> input({ 1.5f, 1.5f, 2.5f, 2.5f, 3.5f, 3.5f });
3561     std::vector<float> output({ 2.5f });
3562
3563     return MeanTestHelper<ArmnnType, T, 2, 1>(
3564             workloadFactory, memoryManager, inputShape, input, {}, false, outputShape, output);
3565 }
3566
3567 template<armnn::DataType ArmnnType, typename T>
3568 LayerTestResult<T, 3> MeanSimpleAxisTest(
3569         armnn::IWorkloadFactory& workloadFactory,
3570         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3571 {
3572     const unsigned int inputShape[] = { 2, 3, 1, 2 };
3573     const unsigned int outputShape[] = { 3, 1, 2 };
3574
3575     std::vector<float> input({ 1.5f, 2.5f, 3.5f, 4.5f, 5.5f, 6.5f, 1.5f, 2.5f, 3.5f, 4.5f, 5.5f, 6.5f });
3576     std::vector<float> output({ 1.5f, 2.5f, 3.5f, 4.5f, 5.5f, 6.5f });
3577
3578     return MeanTestHelper<ArmnnType, T, 4, 3>(
3579             workloadFactory, memoryManager, inputShape, input, { 0 }, false, outputShape, output);
3580 }
3581
3582 template<armnn::DataType ArmnnType, typename T>
3583 LayerTestResult<T, 4> MeanKeepDimsTest(
3584         armnn::IWorkloadFactory& workloadFactory,
3585         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3586 {
3587     const unsigned int inputShape[] = { 1, 1, 3, 2 };
3588     const unsigned int outputShape[] = { 1, 1, 1, 2 };
3589
3590     std::vector<float> input({ 1.5f, 1.5f, 2.5f, 2.5f, 3.5f, 3.5f });
3591     std::vector<float> output({ 2.5f, 2.5f });
3592
3593     return MeanTestHelper<ArmnnType, T, 4, 4>(
3594             workloadFactory, memoryManager, inputShape, input, { 2 }, true, outputShape, output);
3595 }
3596
3597 template<armnn::DataType ArmnnType, typename T>
3598 LayerTestResult<T, 4> MeanMultipleDimsTest(
3599         armnn::IWorkloadFactory& workloadFactory,
3600         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3601 {
3602     const unsigned int inputShape[] = { 2, 3, 1, 2 };
3603     const unsigned int outputShape[] = { 1, 3, 1, 1 };
3604
3605     std::vector<float> input({ 1.5f, 2.5f, 3.5f, 4.5f, 5.5f, 6.5f, 1.5f, 2.5f, 3.5f, 4.5f, 5.5f, 6.5 });
3606     std::vector<float> output({ 2.0f, 4.0f, 6.0f });
3607
3608     return MeanTestHelper<ArmnnType, T, 4, 4>(
3609             workloadFactory, memoryManager, inputShape, input, { 0, 3 }, true, outputShape, output);
3610 }
3611
3612 template<armnn::DataType ArmnnType, typename T>
3613 LayerTestResult<T, 1> MeanVts1Test(
3614         armnn::IWorkloadFactory& workloadFactory,
3615         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3616 {
3617     const unsigned int inputShape[] = { 4, 3, 2 };
3618     const unsigned int outputShape[] = { 2 };
3619
3620     std::vector<float> input({ 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f,
3621                                15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f });
3622     std::vector<float> output({ 12.0f, 13.0f });
3623
3624     return MeanTestHelper<ArmnnType, T, 3, 1>(
3625             workloadFactory, memoryManager, inputShape, input, { 0, 1 }, false, outputShape, output);
3626 }
3627
3628 template<armnn::DataType ArmnnType, typename T>
3629 LayerTestResult<T, 3> MeanVts2Test(
3630         armnn::IWorkloadFactory& workloadFactory,
3631         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3632 {
3633     const unsigned int inputShape[] = { 4, 3, 2 };
3634     const unsigned int outputShape[] = { 1, 3, 1 };
3635
3636     std::vector<float> input({ 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f,
3637                                15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f });
3638     std::vector<float> output({ 10.5f, 12.5f, 14.5f });
3639
3640     return MeanTestHelper<ArmnnType, T, 3, 3>(
3641             workloadFactory, memoryManager, inputShape, input, { 0, 2 }, true, outputShape, output);
3642 }
3643
3644 template<armnn::DataType ArmnnType, typename T>
3645 LayerTestResult<T, 3> MeanVts3Test(
3646         armnn::IWorkloadFactory& workloadFactory,
3647         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3648 {
3649     const unsigned int inputShape[] = { 1, 2, 2, 1 };
3650     const unsigned int outputShape[] = { 1, 2, 1 };
3651
3652     std::vector<float> input({ 1.0f, 2.0f, 3.0f, 4.0f });
3653     std::vector<float> output({ 1.5f, 3.5f });
3654
3655     return MeanTestHelper<ArmnnType, T, 4, 3>(
3656             workloadFactory, memoryManager, inputShape, input, { 2 }, false, outputShape, output);
3657 }
3658
3659 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
3660 LayerTestResult<T, 3> ConcatDifferentInputOutputQParamTest(
3661         armnn::IWorkloadFactory& workloadFactory,
3662         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
3663         bool useSubtensor)
3664 {
3665     // Defines the tensor descriptors.
3666     armnn::TensorInfo outputTensorInfo({ 3, 6, 3 }, ArmnnType);
3667     armnn::TensorInfo inputTensorInfo1({ 3, 6, 2 }, ArmnnType);
3668     armnn::TensorInfo inputTensorInfo2({ 3, 6, 1 }, ArmnnType);
3669
3670     std::vector<armnn::TensorShape> inputTensorShapes({inputTensorInfo1.GetShape(), inputTensorInfo2.GetShape()});
3671
3672     // Quantized input1 tensor.
3673     const float inputScale1 = 0.5f;
3674     const int32_t inputOffset1 = 5;
3675
3676     auto input1 = MakeTensor<T, 3>(inputTensorInfo1, std::vector<T>(
3677     {
3678         1, 2, 3,
3679         4, 5, 6,
3680         7, 8, 9,
3681         10, 11, 12,
3682         13, 14, 15,
3683         16, 17, 18,
3684
3685         19, 20, 21,
3686         22, 23, 24,
3687         25, 26, 27,
3688         28, 29, 30,
3689         31, 32, 33,
3690         34, 35, 36
3691     }));
3692
3693     // Quatized input2 tensor.
3694     const float inputScale2 = 0.2f;
3695     const int32_t inputOffset2 = 10;
3696
3697     auto input2 = MakeTensor<T, 3>(inputTensorInfo2, std::vector<T>(
3698     {
3699         37, 38, 39,
3700         40, 41, 42,
3701         43, 44, 45,
3702         46, 47, 48,
3703         49, 50, 51,
3704         52, 53, 54
3705     }));
3706
3707     // Quantized output tensor.
3708     const float outputScale = 0.1f;
3709     const int32_t outputOffset = 20;
3710
3711     LayerTestResult<T, 3> ret(outputTensorInfo);
3712
3713     ret.outputExpected = MakeTensor<T, 3>(outputTensorInfo, std::vector<T>(
3714     {
3715         0,   5,  74,
3716         10,  15,  76,
3717         20,  25,  78,
3718         30,  35,  80,
3719         40,  45,  82,
3720         50,  55,  84,
3721
3722         60,  65,  86,
3723         70,  75,  88,
3724         80,  85,  90,
3725         90,  95,  92,
3726         100, 105,  94,
3727         110, 115,  96,
3728
3729         120, 125,  98,
3730         130, 135, 100,
3731         140, 145, 102,
3732         150, 155, 104,
3733         160, 165, 106,
3734         170, 175, 108
3735     }));
3736
3737     outputTensorInfo.SetQuantizationScale(outputScale);
3738     outputTensorInfo.SetQuantizationOffset(outputOffset);
3739     inputTensorInfo1.SetQuantizationScale(inputScale1);
3740     inputTensorInfo1.SetQuantizationOffset(inputOffset1);
3741     inputTensorInfo2.SetQuantizationScale(inputScale2);
3742     inputTensorInfo2.SetQuantizationOffset(inputOffset2);
3743
3744     std::vector<unsigned int> wOrigin1 = { 0, 0, 0 }; //Extent of the window is defined by size of input[0].
3745     armnn::ConcatQueueDescriptor::ViewOrigin window1(wOrigin1);
3746
3747     std::vector<unsigned int> wOrigin2 = { 0, 0, 2 }; //Extent of the window is defined by size of input[1].
3748     armnn::ConcatQueueDescriptor::ViewOrigin window2(wOrigin2);
3749
3750     std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
3751
3752     bool subTensorsSupported = useSubtensor && workloadFactory.SupportsSubTensors();
3753
3754     std::unique_ptr<armnn::ITensorHandle> inputHandle1 =
3755             subTensorsSupported ?
3756             workloadFactory.CreateSubTensorHandle(*outputHandle, inputTensorInfo1.GetShape(), wOrigin1.data()) :
3757             workloadFactory.CreateTensorHandle(inputTensorInfo1);
3758
3759     std::unique_ptr<armnn::ITensorHandle> inputHandle2 =
3760             subTensorsSupported ?
3761             workloadFactory.CreateSubTensorHandle(*outputHandle, inputTensorInfo2.GetShape(), wOrigin2.data()) :
3762             workloadFactory.CreateTensorHandle(inputTensorInfo2);
3763
3764     armnn::ConcatQueueDescriptor data;
3765     armnn::OriginsDescriptor desc = armnn::CreateDescriptorForConcatenation(
3766             inputTensorShapes.begin(),inputTensorShapes.end(), 2);
3767     data.m_Parameters = desc;
3768
3769     armnn::WorkloadInfo info;
3770     AddInputToWorkload(data, info, inputTensorInfo1, inputHandle1.get());
3771     AddInputToWorkload(data, info, inputTensorInfo2, inputHandle2.get());
3772     AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
3773
3774     data.m_ViewOrigins.push_back(window1);
3775     data.m_ViewOrigins.push_back(window2);
3776
3777     std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateConcat(data, info);
3778
3779     inputHandle1->Allocate();
3780     inputHandle2->Allocate();
3781     outputHandle->Allocate();
3782
3783     CopyDataToITensorHandle(inputHandle1.get(), &input1[0][0][0]);
3784     CopyDataToITensorHandle(inputHandle2.get(), &input2[0][0][0]);
3785
3786     workload->PostAllocationConfigure();
3787     workload->Execute();
3788
3789     CopyDataFromITensorHandle(&ret.output[0][0][0], outputHandle.get());
3790
3791     return ret;
3792 }
3793
3794 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
3795 LayerTestResult<T, 4> PreluTest(
3796         armnn::IWorkloadFactory& workloadFactory,
3797         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3798 {
3799     armnn::TensorInfo inputTensorInfo ({ 1, 2, 2, 3 }, ArmnnType);
3800     armnn::TensorInfo alphaTensorInfo ({ 1, 1, 1, 3 }, ArmnnType);
3801     armnn::TensorInfo outputTensorInfo({ 1, 2, 2, 3 }, ArmnnType);
3802
3803     if (armnn::IsQuantizedType<T>())
3804     {
3805         inputTensorInfo.SetQuantizationScale(0.25f);
3806         inputTensorInfo.SetQuantizationOffset(128);
3807         alphaTensorInfo.SetQuantizationScale(0.25f);
3808         alphaTensorInfo.SetQuantizationOffset(50);
3809         outputTensorInfo.SetQuantizationScale(0.5f);
3810         outputTensorInfo.SetQuantizationOffset(120);
3811     }
3812
3813     std::vector<float> inputData
3814     {
3815         // Expected quantized values:
3816         // 128, 128, 128, 132, 132, 132, 124, 124, 124, 120, 120, 120
3817         0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, -1.0f, -1.0f, -1.0f, -2.0f, -2.0f, -2.0f
3818     };
3819     std::vector<float> alphaData
3820     {
3821         // Expected quantized values:
3822         // 50, 54, 58
3823         0.0f, 1.0f, 2.0f
3824     };
3825     std::vector<float> outputExpectedData =
3826     {
3827         // Expected quantized values:
3828         // 20, 120, 120, 122, 122, 122, 120, 118, 116, 120, 116, 112
3829        0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, -1.0f, -2.0f, 0.0f, -2.0f, -4.0f
3830     };
3831
3832     auto input = MakeTensor<T, 4>(inputTensorInfo, QuantizedVector<T>(inputTensorInfo.GetQuantizationScale(),
3833                                                                       inputTensorInfo.GetQuantizationOffset(),
3834                                                                       inputData));
3835     auto alpha = MakeTensor<T, 4>(alphaTensorInfo, QuantizedVector<T>(alphaTensorInfo.GetQuantizationScale(),
3836                                                                       alphaTensorInfo.GetQuantizationOffset(),
3837                                                                       alphaData));
3838
3839     LayerTestResult<T, 4> result(outputTensorInfo);
3840     result.outputExpected = MakeTensor<T, 4>(outputTensorInfo,
3841                                              QuantizedVector<T>(outputTensorInfo.GetQuantizationScale(),
3842                                                                 outputTensorInfo.GetQuantizationOffset(),
3843                                                                 outputExpectedData));
3844
3845     std::unique_ptr <armnn::ITensorHandle> inputHandle  = workloadFactory.CreateTensorHandle(inputTensorInfo);
3846     std::unique_ptr <armnn::ITensorHandle> alphaHandle  = workloadFactory.CreateTensorHandle(alphaTensorInfo);
3847     std::unique_ptr <armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
3848
3849     armnn::PreluQueueDescriptor descriptor;
3850     armnn::WorkloadInfo info;
3851     AddInputToWorkload (descriptor, info, inputTensorInfo,  inputHandle.get());
3852     AddInputToWorkload (descriptor, info, alphaTensorInfo,  alphaHandle.get());
3853     AddOutputToWorkload(descriptor, info, outputTensorInfo, outputHandle.get());
3854
3855     std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreatePrelu(descriptor, info);
3856
3857     inputHandle->Allocate();
3858     alphaHandle->Allocate();
3859     outputHandle->Allocate();
3860
3861     CopyDataToITensorHandle(inputHandle.get(), &input[0][0][0][0]);
3862     CopyDataToITensorHandle(alphaHandle.get(), &alpha[0][0][0][0]);
3863
3864     workload->Execute();
3865
3866     CopyDataFromITensorHandle(&result.output[0][0][0][0], outputHandle.get());
3867
3868     return result;
3869 }
3870
3871 template<armnn::DataType ArmnnType,
3872         std::size_t InputDim,
3873         std::size_t OutputDim,
3874         typename T = armnn::ResolveType<ArmnnType>>
3875 LayerTestResult<T, OutputDim> BatchToSpaceNdHelper(
3876         armnn::IWorkloadFactory &workloadFactory,
3877         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager,
3878         const armnn::DataLayout& dataLayout,
3879         const unsigned int *inputShape,
3880         const std::vector<float> &inputData,
3881         const std::vector<unsigned int> &blockShape,
3882         const std::vector<std::pair<unsigned int, unsigned int>> &crops,
3883         const unsigned int *outputShape,
3884         const std::vector<float> &outputData,
3885         float scale = 1.0f,
3886         int32_t offset = 0)
3887 {
3888     armnn::TensorInfo inputTensorInfo(InputDim, inputShape, ArmnnType);
3889     armnn::TensorInfo outputTensorInfo(OutputDim, outputShape, ArmnnType);
3890
3891     inputTensorInfo.SetQuantizationScale(scale);
3892     inputTensorInfo.SetQuantizationOffset(offset);
3893
3894     outputTensorInfo.SetQuantizationScale(scale);
3895     outputTensorInfo.SetQuantizationOffset(offset);
3896
3897     auto input = MakeTensor<T, InputDim>(inputTensorInfo, ConvertToDataType<ArmnnType>(inputData, inputTensorInfo));
3898
3899     LayerTestResult<T, OutputDim> result(outputTensorInfo);
3900     result.outputExpected = MakeTensor<T, OutputDim>(outputTensorInfo,
3901                                                      ConvertToDataType<ArmnnType>(outputData, outputTensorInfo));
3902
3903     std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
3904     std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
3905
3906     armnn::BatchToSpaceNdQueueDescriptor data;
3907     data.m_Parameters.m_DataLayout = dataLayout;
3908     data.m_Parameters.m_BlockShape = blockShape;
3909     data.m_Parameters.m_Crops = crops;
3910     armnn::WorkloadInfo info;
3911     AddInputToWorkload(data, info, inputTensorInfo, inputHandle.get());
3912     AddOutputToWorkload(data, info, outputTensorInfo, outputHandle.get());
3913
3914     std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateBatchToSpaceNd(data, info);
3915
3916     inputHandle->Allocate();
3917     outputHandle->Allocate();
3918
3919     CopyDataToITensorHandle(inputHandle.get(), input.origin());
3920
3921     workload->PostAllocationConfigure();
3922     workload->Execute();
3923
3924     CopyDataFromITensorHandle(&result.output[0][0][0][0], outputHandle.get());
3925
3926     return result;
3927 }
3928
3929 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
3930 LayerTestResult<T, 4> BatchToSpaceNdNhwcTest1(
3931         armnn::IWorkloadFactory& workloadFactory,
3932         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3933 {
3934     const unsigned int inputShape[] = {4, 2, 2, 1};
3935     const unsigned int outputShape[] = {1, 4, 4, 1};
3936
3937     std::vector<float> input({
3938                                      // Batch 0, Height 0, Width (2) x Channel (1)
3939                                      1.0f, 3.0f,
3940                                      // Batch 0, Height 1, Width (2) x Channel (1)
3941                                      9.0f, 11.0f,
3942
3943
3944                                      // Batch 1, Height 0, Width (2) x Channel (1)
3945                                      2.0f, 4.0f,
3946                                      // Batch 1, Height 1, Width (2) x Channel (1)
3947                                      10.0f, 12.0f,
3948
3949
3950                                      // Batch 2, Height 0, Width (2) x Channel (1)
3951                                      5.0f, 7.0f,
3952                                      // Batch 2, Height 1, Width (2) x Channel (1)
3953                                      13.0f, 15.0f,
3954
3955                                      // Batch 3, Height 0, Width (2) x Channel (3)
3956                                      6.0f, 8.0f,
3957                                      // Batch 3, Height 1, Width (2) x Channel (1)
3958                                      14.0f, 16.0f
3959                              });
3960
3961     std::vector<float> expectedOutput({
3962                                               1.0f,   2.0f,  3.0f,  4.0f,
3963                                               5.0f,   6.0f,  7.0f,  8.0f,
3964                                               9.0f,  10.0f, 11.0f,  12.0f,
3965                                               13.0f, 14.0f, 15.0f,  16.0f
3966                                       });
3967
3968     std::vector<unsigned int> blockShape {2, 2};
3969     std::vector<std::pair<unsigned int, unsigned int>> crops = {{0, 0}, {0, 0}};
3970
3971     return BatchToSpaceNdHelper<ArmnnType, 4, 4>(workloadFactory, memoryManager,
3972                                                                 armnn::DataLayout::NHWC, inputShape, input, blockShape,
3973                                                                 crops, outputShape, expectedOutput);
3974 }
3975
3976 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
3977 LayerTestResult<T, 4> BatchToSpaceNdNhwcTest2(
3978         armnn::IWorkloadFactory& workloadFactory,
3979         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
3980 {
3981     const unsigned int inputShape[] = {4, 1, 1, 1};
3982     const unsigned int outputShape[] = {1, 2, 2, 1};
3983
3984     std::vector<float> input({
3985                                      // Batch 0, Height 0, Width (2) x Channel (1)
3986                                      1.0f, 2.0f, 3.0f, 4.0f
3987                              });
3988
3989     std::vector<float> expectedOutput({1.0f, 2.0f, 3.0f, 4.0f});
3990
3991     std::vector<unsigned int> blockShape({2, 2});
3992     std::vector<std::pair<unsigned int, unsigned int>> crops = {{0, 0}, {0, 0}};
3993
3994     return BatchToSpaceNdHelper<ArmnnType, 4, 4>(workloadFactory, memoryManager,
3995                                                                 armnn::DataLayout::NHWC, inputShape, input, blockShape,
3996                                                                 crops, outputShape, expectedOutput);
3997 }
3998
3999 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
4000 LayerTestResult<T, 4> BatchToSpaceNdNhwcTest3(
4001         armnn::IWorkloadFactory& workloadFactory,
4002         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
4003 {
4004     const unsigned int inputShape[] = {4, 1, 1, 3};
4005     const unsigned int outputShape[] = {1, 2, 2, 3};
4006
4007     std::vector<float> input({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f});
4008
4009     std::vector<float> expectedOutput({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f});
4010
4011     std::vector<unsigned int> blockShape({2, 2});
4012     std::vector<std::pair<unsigned int, unsigned int>> crops = {{0, 0}, {0, 0}};
4013
4014     return BatchToSpaceNdHelper<ArmnnType, 4, 4>(workloadFactory, memoryManager,
4015                                                                 armnn::DataLayout::NHWC, inputShape, input, blockShape,
4016                                                                 crops, outputShape, expectedOutput);
4017 }
4018
4019 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
4020 LayerTestResult<T, 4> BatchToSpaceNdNhwcTest4(
4021         armnn::IWorkloadFactory& workloadFactory,
4022         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
4023 {
4024     const unsigned int inputShape[] = {8, 1, 3, 1};
4025     const unsigned int outputShape[] = {2, 2, 4, 1};
4026
4027     std::vector<float> input({
4028                                      0.0f, 1.0f, 3.0f,
4029                                      0.0f, 9.0f, 11.0f,
4030                                      0.0f, 2.0f, 4.0f,
4031                                      0.0f, 10.0f, 12.0f,
4032                                      0.0f, 5.0f, 7.0f,
4033                                      0.0f, 13.0f, 15.0f,
4034                                      0.0f, 6.0f, 8.0f,
4035                                      0.0f, 14.0f, 16.0f
4036                              });
4037
4038     std::vector<float> expectedOutput({
4039                                               1.0f, 2.0f, 3.0f, 4.0f,
4040                                               5.0f, 6.0f, 7.0f, 8.0f,
4041                                               9.0f, 10.0f, 11.0f, 12.0f,
4042                                               13.0f, 14.0f, 15.0f, 16.0f
4043                                       });
4044
4045     std::vector<unsigned int> blockShape({2, 2});
4046     std::vector<std::pair<unsigned int, unsigned int>> crops = {{0, 0}, {2, 0}};
4047
4048     return BatchToSpaceNdHelper<ArmnnType, 4, 4>(workloadFactory, memoryManager,
4049                                                                 armnn::DataLayout::NHWC, inputShape, input, blockShape,
4050                                                                 crops, outputShape, expectedOutput);
4051 }
4052
4053 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
4054 LayerTestResult<T, 4> BatchToSpaceNdNhwcTest5(
4055         armnn::IWorkloadFactory& workloadFactory,
4056         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
4057 {
4058     const unsigned int inputShape[] = {4, 2, 2, 1};
4059     const unsigned int outputShape[] = {1, 4, 4, 1};
4060
4061     std::vector<float> input({1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16});
4062     std::vector<float> expectedOutput({1, 5, 2, 6, 9, 13, 10, 14, 3, 7, 4, 8, 11, 15, 12, 16});
4063
4064     std::vector<unsigned int> blockShape({2, 2});
4065     std::vector<std::pair<unsigned int, unsigned int>> crops = {{0, 0}, {0, 0}};
4066
4067     return BatchToSpaceNdHelper<ArmnnType, 4, 4>(workloadFactory, memoryManager, armnn::DataLayout::NHWC, inputShape,
4068                                                  input, blockShape, crops, outputShape, expectedOutput);
4069 }
4070
4071 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
4072 LayerTestResult<T, 4> BatchToSpaceNdNhwcTest6(
4073         armnn::IWorkloadFactory& workloadFactory,
4074         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
4075 {
4076     const unsigned int inputShape[] = {4, 1, 1, 1};
4077     const unsigned int outputShape[] = {1, 2, 2, 1};
4078
4079     std::vector<float> input({
4080                                      // Batch 0, Height 0, Width (2) x Channel (1)
4081                                      1, 2, 3, 4
4082                              });
4083
4084     std::vector<float> expectedOutput({1, 2, 3, 4});
4085
4086     std::vector<unsigned int> blockShape({2, 2});
4087     std::vector<std::pair<unsigned int, unsigned int>> crops = {{0, 0}, {0, 0}};
4088
4089     return BatchToSpaceNdHelper<ArmnnType, 4, 4>(workloadFactory, memoryManager,
4090                                                  armnn::DataLayout::NHWC, inputShape, input, blockShape,
4091                                                  crops, outputShape, expectedOutput);
4092 }
4093
4094 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
4095 LayerTestResult<T, 4> BatchToSpaceNdNhwcTest7(
4096         armnn::IWorkloadFactory& workloadFactory,
4097         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
4098 {
4099     const unsigned int inputShape[] = {4, 1, 1, 3};
4100     const unsigned int outputShape[] = {1, 2, 2, 3};
4101
4102     std::vector<float> input({1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12});
4103
4104     std::vector<float> expectedOutput({1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12});
4105
4106     std::vector<unsigned int> blockShape({2, 2});
4107     std::vector<std::pair<unsigned int, unsigned int>> crops = {{0, 0}, {0, 0}};
4108
4109     return BatchToSpaceNdHelper<ArmnnType, 4, 4>(workloadFactory, memoryManager,
4110                                                  armnn::DataLayout::NHWC, inputShape, input, blockShape,
4111                                                  crops, outputShape, expectedOutput);
4112 }
4113
4114 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
4115 LayerTestResult<T, 4> BatchToSpaceNdNchwTest1(
4116         armnn::IWorkloadFactory &workloadFactory,
4117         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
4118 {
4119     const unsigned int inputShape[] = {4, 3, 1, 1};
4120     const unsigned int outputShape[] = {1, 3, 2, 2};
4121
4122     std::vector<float> input({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f});
4123
4124     std::vector<float> expectedOutput({
4125                                               // Batch 0, Channel 0, Height (2) x Width (2)
4126                                               1.0f,  4.0f,
4127                                               7.0f, 10.0f,
4128
4129                                               // Batch 0, Channel 1, Height (2) x Width (2)
4130                                               2.0f,  5.0f,
4131                                               8.0f, 11.0f,
4132
4133                                               // Batch 0, Channel 2, Height (2) x Width (2)
4134                                               3.0f,  6.0f,
4135                                               9.0f, 12.0f,
4136                                       });
4137
4138     std::vector<unsigned int> blockShape({2, 2});
4139     std::vector<std::pair<unsigned int, unsigned int>> crops = {{0, 0}, {0, 0}};
4140
4141     return BatchToSpaceNdHelper<ArmnnType, 4, 4>(workloadFactory, memoryManager,
4142                                                                 armnn::DataLayout::NCHW, inputShape, input, blockShape,
4143                                                                 crops, outputShape, expectedOutput);
4144 }
4145
4146 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
4147 LayerTestResult<T, 4> BatchToSpaceNdNchwTest2(
4148         armnn::IWorkloadFactory& workloadFactory,
4149         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
4150 {
4151     const unsigned int inputShape[] = {4, 1, 1, 1};
4152     const unsigned int outputShape[] = {1, 1, 2, 2};
4153
4154     std::vector<float> input({
4155                                      // Batch 0, Height 0, Width (2) x Channel (1)
4156                                      1.0f, 2.0f, 3.0f, 4.0f
4157                              });
4158
4159     std::vector<float> expectedOutput({1.0f, 2.0f, 3.0f, 4.0f});
4160
4161     std::vector<unsigned int> blockShape({2, 2});
4162     std::vector<std::pair<unsigned int, unsigned int>> crops = {{0, 0}, {0, 0}};
4163
4164     return BatchToSpaceNdHelper<ArmnnType, 4, 4>(workloadFactory, memoryManager,
4165                                                                 armnn::DataLayout::NCHW, inputShape, input, blockShape,
4166                                                                 crops, outputShape, expectedOutput);
4167 }
4168
4169 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
4170 LayerTestResult<T, 4> BatchToSpaceNdNchwTest3(
4171         armnn::IWorkloadFactory& workloadFactory,
4172         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
4173 {
4174     const unsigned int inputShape[] = {4, 3, 1, 1};
4175     const unsigned int outputShape[] = {1, 3, 2, 2};
4176
4177     std::vector<float> input({1.0f, 3.0f, 5.0f, 7.0f, 9.0f, 11.0f, 2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f});
4178
4179     std::vector<float> expectedOutput({
4180                                               // Batch 0, Channel 0, Height (2) x Width (2)
4181                                               1.0f,  7.0f,
4182                                               2.0f,  8.0f,
4183
4184                                               // Batch 0, Channel 1, Height (2) x Width (2)
4185                                               3.0f,  9.0f,
4186                                               4.0f, 10.0f,
4187
4188                                               // Batch 0, Channel 2, Height (2) x Width (2)
4189                                               5.0f, 11.0f,
4190                                               6.0f, 12.0f,
4191                                       });
4192
4193     std::vector<unsigned int> blockShape({2, 2});
4194     std::vector<std::pair<unsigned int, unsigned int>> crops = {{0, 0}, {0, 0}};
4195
4196     return BatchToSpaceNdHelper<ArmnnType, 4, 4>(workloadFactory, memoryManager,
4197                                                                 armnn::DataLayout::NCHW, inputShape, input, blockShape,
4198                                                                 crops, outputShape, expectedOutput);
4199 }
4200
4201 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
4202 LayerTestResult<T, 4> BatchToSpaceNdNchwTest4(
4203         armnn::IWorkloadFactory &workloadFactory,
4204         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
4205 {
4206     const unsigned int inputShape[] = {4, 3, 1, 1};
4207     const unsigned int outputShape[] = {1, 3, 2, 2};
4208
4209     std::vector<float> input({1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12});
4210
4211     std::vector<float> expectedOutput({
4212                                               // Batch 0, Channel 0, Height (2) x Width (2)
4213                                               1,  4,
4214                                               7, 10,
4215
4216                                               // Batch 0, Channel 1, Height (2) x Width (2)
4217                                               2,  5,
4218                                               8, 11,
4219
4220                                               // Batch 0, Channel 2, Height (2) x Width (2)
4221                                               3,  6,
4222                                               9, 12,
4223                                       });
4224
4225     std::vector<unsigned int> blockShape({2, 2});
4226     std::vector<std::pair<unsigned int, unsigned int>> crops = {{0, 0}, {0, 0}};
4227
4228     return BatchToSpaceNdHelper<ArmnnType, 4, 4>(workloadFactory, memoryManager,
4229                                                  armnn::DataLayout::NCHW, inputShape, input, blockShape,
4230                                                  crops, outputShape, expectedOutput);
4231 }
4232
4233 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
4234 LayerTestResult<T, 4> BatchToSpaceNdNchwTest5(
4235         armnn::IWorkloadFactory& workloadFactory,
4236         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
4237 {
4238     const unsigned int inputShape[] = {4, 1, 1, 1};
4239     const unsigned int outputShape[] = {1, 1, 2, 2};
4240
4241     std::vector<float> input({
4242                                      // Batch 0, Height 0, Width (2) x Channel (1)
4243                                      1, 2, 3, 4
4244                              });
4245
4246     std::vector<float> expectedOutput({1, 2, 3, 4});
4247
4248     std::vector<unsigned int> blockShape({2, 2});
4249     std::vector<std::pair<unsigned int, unsigned int>> crops = {{0, 0}, {0, 0}};
4250
4251     return BatchToSpaceNdHelper<ArmnnType, 4, 4>(workloadFactory, memoryManager,
4252                                                  armnn::DataLayout::NCHW, inputShape, input, blockShape,
4253                                                  crops, outputShape, expectedOutput);
4254 }
4255
4256 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
4257 LayerTestResult<T, 4> BatchToSpaceNdNchwTest6(
4258         armnn::IWorkloadFactory& workloadFactory,
4259         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
4260 {
4261     const unsigned int inputShape[] = {4, 3, 1, 1};
4262     const unsigned int outputShape[] = {1, 3, 2, 2};
4263
4264     std::vector<float> input({1, 3, 5, 7, 9, 11, 2, 4, 6, 8, 10, 12});
4265
4266     std::vector<float> expectedOutput({
4267                                               // Batch 0, Channel 0, Height (2) x Width (2)
4268                                               1,  7,
4269                                               2,  8,
4270
4271                                               // Batch 0, Channel 1, Height (2) x Width (2)
4272                                               3,  9,
4273                                               4, 10,
4274
4275                                               // Batch 0, Channel 2, Height (2) x Width (2)
4276                                               5, 11,
4277                                               6, 12,
4278                                       });
4279
4280     std::vector<unsigned int> blockShape({2, 2});
4281     std::vector<std::pair<unsigned int, unsigned int>> crops = {{0, 0}, {0, 0}};
4282
4283     return BatchToSpaceNdHelper<ArmnnType, 4, 4>(workloadFactory, memoryManager,
4284                                                  armnn::DataLayout::NCHW, inputShape, input, blockShape,
4285                                                  crops, outputShape, expectedOutput);
4286 }
4287
4288 template<armnn::DataType ArmnnType, typename T = armnn::ResolveType<ArmnnType>>
4289 LayerTestResult<T, 4> BatchToSpaceNdNchwTest7(
4290         armnn::IWorkloadFactory& workloadFactory,
4291         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager)
4292 {
4293     const unsigned int inputShape[] = {8, 1, 1, 3};
4294     const unsigned int outputShape[] = {2, 1, 2, 4};
4295
4296     std::vector<float> input({
4297                                      0, 1, 3, 0,  9, 11,
4298                                      0, 2, 4, 0, 10, 12,
4299                                      0, 5, 7, 0, 13, 15,
4300                                      0, 6, 8, 0, 14, 16
4301                              });
4302
4303     std::vector<float> expectedOutput({
4304                                               1,  2,  3,  4,
4305                                               5,  6,  7,  8,
4306                                               9, 10, 11, 12,
4307                                               13, 14, 15, 16
4308                                       });
4309
4310     std::vector<unsigned int> blockShape({2, 2});
4311     std::vector<std::pair<unsigned int, unsigned int>> crops = {{0, 0}, {2, 0}};
4312
4313     return BatchToSpaceNdHelper<ArmnnType, 4, 4>(workloadFactory, memoryManager,
4314                                                  armnn::DataLayout::NCHW, inputShape, input, blockShape,
4315                                                  crops, outputShape, expectedOutput);
4316 }
4317
4318 template LayerTestResult<typename armnn::ResolveType<armnn::DataType::Float32>, 4>
4319 PreluTest<armnn::DataType::Float32>(
4320         armnn::IWorkloadFactory& workloadFactory,
4321         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
4322
4323 template LayerTestResult<typename armnn::ResolveType<armnn::DataType::QuantisedAsymm8>, 4>
4324 PreluTest<armnn::DataType::QuantisedAsymm8>(
4325         armnn::IWorkloadFactory& workloadFactory,
4326         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
4327
4328 template LayerTestResult<typename armnn::ResolveType<armnn::DataType::QuantisedSymm16>, 4>
4329 PreluTest<armnn::DataType::QuantisedSymm16>(
4330         armnn::IWorkloadFactory& workloadFactory,
4331         const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
4332
4333 //
4334 // TransposeConvolution2d
4335 //
4336
4337 // Simple biased
4338 LayerTestResult<float, 4> SimpleTransposeConvolution2dFloatNchwTest(
4339     armnn::IWorkloadFactory& workloadFactory,
4340     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
4341
4342 LayerTestResult<float, 4> SimpleTransposeConvolution2dFloatNhwcTest(
4343     armnn::IWorkloadFactory& workloadFactory,
4344     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
4345
4346 LayerTestResult<uint8_t, 4> SimpleTransposeConvolution2dUint8NchwTest(
4347     armnn::IWorkloadFactory& workloadFactory,
4348     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
4349
4350 LayerTestResult<uint8_t, 4> SimpleTransposeConvolution2dUint8NhwcTest(
4351     armnn::IWorkloadFactory& workloadFactory,
4352     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
4353
4354 LayerTestResult<int16_t, 4> SimpleTransposeConvolution2dInt16NchwTest(
4355     armnn::IWorkloadFactory& workloadFactory,
4356     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
4357
4358 LayerTestResult<int16_t, 4> SimpleTransposeConvolution2dInt16NhwcTest(
4359     armnn::IWorkloadFactory& workloadFactory,
4360     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
4361
4362 // Simple unbiased
4363 LayerTestResult<float, 4> UnbiasedSimpleTransposeConvolution2dFloatNchwTest(
4364     armnn::IWorkloadFactory& workloadFactory,
4365     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
4366
4367 LayerTestResult<float, 4> UnbiasedSimpleTransposeConvolution2dFloatNhwcTest(
4368     armnn::IWorkloadFactory& workloadFactory,
4369     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
4370
4371 LayerTestResult<uint8_t, 4> UnbiasedSimpleTransposeConvolution2dUint8NchwTest(
4372     armnn::IWorkloadFactory& workloadFactory,
4373     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
4374
4375 LayerTestResult<uint8_t, 4> UnbiasedSimpleTransposeConvolution2dUint8NhwcTest(
4376     armnn::IWorkloadFactory& workloadFactory,
4377     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
4378
4379 LayerTestResult<int16_t, 4> UnbiasedSimpleTransposeConvolution2dInt16NchwTest(
4380     armnn::IWorkloadFactory& workloadFactory,
4381     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
4382
4383 LayerTestResult<int16_t, 4> UnbiasedSimpleTransposeConvolution2dInt16NhwcTest(
4384     armnn::IWorkloadFactory& workloadFactory,
4385     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
4386
4387 // Padded biased
4388 LayerTestResult<float, 4> PaddedTransposeConvolution2dFloatNchwTest(
4389     armnn::IWorkloadFactory& workloadFactory,
4390     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
4391
4392 LayerTestResult<float, 4> PaddedTransposeConvolution2dFloatNhwcTest(
4393     armnn::IWorkloadFactory& workloadFactory,
4394     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
4395
4396 LayerTestResult<uint8_t, 4> PaddedTransposeConvolution2dUint8NchwTest(
4397     armnn::IWorkloadFactory& workloadFactory,
4398     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
4399
4400 LayerTestResult<uint8_t, 4> PaddedTransposeConvolution2dUint8NhwcTest(
4401     armnn::IWorkloadFactory& workloadFactory,
4402     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
4403
4404 LayerTestResult<int16_t, 4> PaddedTransposeConvolution2dInt16NchwTest(
4405     armnn::IWorkloadFactory& workloadFactory,
4406     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
4407
4408 LayerTestResult<int16_t, 4> PaddedTransposeConvolution2dInt16NhwcTest(
4409     armnn::IWorkloadFactory& workloadFactory,
4410     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
4411
4412 // Padded unbiased
4413 LayerTestResult<float, 4> UnbiasedPaddedTransposeConvolution2dFloatNchwTest(
4414     armnn::IWorkloadFactory& workloadFactory,
4415     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
4416
4417 LayerTestResult<float, 4> UnbiasedPaddedTransposeConvolution2dFloatNhwcTest(
4418     armnn::IWorkloadFactory& workloadFactory,
4419     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
4420
4421 LayerTestResult<uint8_t, 4> UnbiasedPaddedTransposeConvolution2dUint8NchwTest(
4422     armnn::IWorkloadFactory& workloadFactory,
4423     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
4424
4425 LayerTestResult<uint8_t, 4> UnbiasedPaddedTransposeConvolution2dUint8NhwcTest(
4426     armnn::IWorkloadFactory& workloadFactory,
4427     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
4428
4429 LayerTestResult<int16_t, 4> UnbiasedPaddedTransposeConvolution2dInt16NchwTest(
4430     armnn::IWorkloadFactory& workloadFactory,
4431     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
4432
4433 LayerTestResult<int16_t, 4> UnbiasedPaddedTransposeConvolution2dInt16NhwcTest(
4434     armnn::IWorkloadFactory& workloadFactory,
4435     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
4436
4437 // Strided biased
4438 LayerTestResult<float, 4> StridedTransposeConvolution2dFloatNchwTest(
4439     armnn::IWorkloadFactory& workloadFactory,
4440     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
4441
4442 LayerTestResult<float, 4> StridedTransposeConvolution2dFloatNhwcTest(
4443     armnn::IWorkloadFactory& workloadFactory,
4444     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
4445
4446 LayerTestResult<uint8_t, 4> StridedTransposeConvolution2dUint8NchwTest(
4447     armnn::IWorkloadFactory& workloadFactory,
4448     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
4449
4450 LayerTestResult<uint8_t, 4> StridedTransposeConvolution2dUint8NhwcTest(
4451     armnn::IWorkloadFactory& workloadFactory,
4452     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
4453
4454 LayerTestResult<int16_t, 4> StridedTransposeConvolution2dInt16NchwTest(
4455     armnn::IWorkloadFactory& workloadFactory,
4456     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
4457
4458 LayerTestResult<int16_t, 4> StridedTransposeConvolution2dInt16NhwcTest(
4459     armnn::IWorkloadFactory& workloadFactory,
4460     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
4461
4462 // Strided unbiased
4463 LayerTestResult<float, 4> UnbiasedStridedTransposeConvolution2dFloatNchwTest(
4464     armnn::IWorkloadFactory& workloadFactory,
4465     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
4466
4467 LayerTestResult<float, 4> UnbiasedStridedTransposeConvolution2dFloatNhwcTest(
4468     armnn::IWorkloadFactory& workloadFactory,
4469     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
4470
4471 LayerTestResult<uint8_t, 4> UnbiasedStridedTransposeConvolution2dUint8NchwTest(
4472     armnn::IWorkloadFactory& workloadFactory,
4473     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
4474
4475 LayerTestResult<uint8_t, 4> UnbiasedStridedTransposeConvolution2dUint8NhwcTest(
4476     armnn::IWorkloadFactory& workloadFactory,
4477     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
4478
4479 LayerTestResult<int16_t, 4> UnbiasedStridedTransposeConvolution2dInt16NchwTest(
4480     armnn::IWorkloadFactory& workloadFactory,
4481     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);
4482
4483 LayerTestResult<int16_t, 4> UnbiasedStridedTransposeConvolution2dInt16NhwcTest(
4484     armnn::IWorkloadFactory& workloadFactory,
4485     const armnn::IBackendInternal::IMemoryManagerSharedPtr& memoryManager);