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