src/backends/cl/test/ClEndToEndTests.cpp

   1 //
   2 // Copyright © 2017 Arm Ltd. All rights reserved.
   3 // SPDX-License-Identifier: MIT
   4 //
   5
   6 #include <backendsCommon/test/EndToEndTestImpl.hpp>
   7
   8 #include <backendsCommon/test/AbsEndToEndTestImpl.hpp>
   9 #include <backendsCommon/test/ArgMinMaxEndToEndTestImpl.hpp>
  10 #include <backendsCommon/test/ComparisonEndToEndTestImpl.hpp>
  11 #include <backendsCommon/test/ConcatEndToEndTestImpl.hpp>
  12 #include <backendsCommon/test/DepthToSpaceEndToEndTestImpl.hpp>
  13 #include <backendsCommon/test/DequantizeEndToEndTestImpl.hpp>
  14 #include <backendsCommon/test/InstanceNormalizationEndToEndTestImpl.hpp>
  15 #include <backendsCommon/test/PreluEndToEndTestImpl.hpp>
  16 #include <backendsCommon/test/QuantizedLstmEndToEndTestImpl.hpp>
  17 #include <backendsCommon/test/SpaceToDepthEndToEndTestImpl.hpp>
  18 #include <backendsCommon/test/SplitterEndToEndTestImpl.hpp>
  19 #include <backendsCommon/test/TransposeConvolution2dEndToEndTestImpl.hpp>
  20
  21 #include <boost/test/unit_test.hpp>
  22
  23 BOOST_AUTO_TEST_SUITE(ClEndToEnd)
  24
  25 std::vector<armnn::BackendId> defaultBackends = {armnn::Compute::GpuAcc};
  26
  27 // Abs
  28 BOOST_AUTO_TEST_CASE(ClAbsEndToEndTestFloat32)
  29 {
  30     AbsEndToEnd<armnn::DataType::Float32>(defaultBackends);
  31 }
  32
  33 // Constant
  34 BOOST_AUTO_TEST_CASE(ConstantUsage_Cl_Float32)
  35 {
  36     ConstantUsageFloat32Test(defaultBackends);
  37 }
  38
  39 BOOST_AUTO_TEST_CASE(ClConcatEndToEndDim0Test)
  40 {
  41     ConcatDim0EndToEnd<armnn::DataType::Float32>(defaultBackends);
  42 }
  43
  44 BOOST_AUTO_TEST_CASE(ClConcatEndToEndDim0Uint8Test)
  45 {
  46     ConcatDim0EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
  47 }
  48
  49 BOOST_AUTO_TEST_CASE(ClConcatEndToEndDim1Test)
  50 {
  51     ConcatDim1EndToEnd<armnn::DataType::Float32>(defaultBackends);
  52 }
  53
  54 BOOST_AUTO_TEST_CASE(ClConcatEndToEndDim1Uint8Test)
  55 {
  56     ConcatDim1EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
  57 }
  58
  59 BOOST_AUTO_TEST_CASE(ClConcatEndToEndDim3Test)
  60 {
  61     ConcatDim3EndToEnd<armnn::DataType::Float32>(defaultBackends);
  62 }
  63
  64 BOOST_AUTO_TEST_CASE(ClConcatEndToEndDim3Uint8Test)
  65 {
  66     ConcatDim3EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
  67 }
  68
  69 // DepthToSpace
  70 BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNchwFloat32)
  71 {
  72     DepthToSpaceEndToEnd<armnn::DataType::Float32>(defaultBackends, armnn::DataLayout::NCHW);
  73 }
  74
  75 BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNchwFloat16)
  76 {
  77     DepthToSpaceEndToEnd<armnn::DataType::Float16>(defaultBackends, armnn::DataLayout::NCHW);
  78 }
  79
  80 BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNchwUint8)
  81 {
  82     DepthToSpaceEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, armnn::DataLayout::NCHW);
  83 }
  84
  85 BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNchwInt16)
  86 {
  87     DepthToSpaceEndToEnd<armnn::DataType::QSymmS16>(defaultBackends, armnn::DataLayout::NCHW);
  88 }
  89
  90 BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNhwcFloat32)
  91 {
  92     DepthToSpaceEndToEnd<armnn::DataType::Float32>(defaultBackends, armnn::DataLayout::NHWC);
  93 }
  94
  95 BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNhwcFloat16)
  96 {
  97     DepthToSpaceEndToEnd<armnn::DataType::Float16>(defaultBackends, armnn::DataLayout::NHWC);
  98 }
  99
 100 BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNhwcUint8)
 101 {
 102     DepthToSpaceEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, armnn::DataLayout::NHWC);
 103 }
 104
 105 BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNhwcInt16)
 106 {
 107     DepthToSpaceEndToEnd<armnn::DataType::QSymmS16>(defaultBackends, armnn::DataLayout::NHWC);
 108 }
 109
 110 // Dequantize
 111 BOOST_AUTO_TEST_CASE(DequantizeEndToEndSimpleTest)
 112 {
 113     DequantizeEndToEndSimple<armnn::DataType::QAsymmU8>(defaultBackends);
 114 }
 115
 116 BOOST_AUTO_TEST_CASE(DequantizeEndToEndOffsetTest)
 117 {
 118     DequantizeEndToEndOffset<armnn::DataType::QAsymmU8>(defaultBackends);
 119 }
 120
 121 BOOST_AUTO_TEST_CASE(ClGreaterSimpleEndToEndTest)
 122 {
 123     const std::vector<uint8_t> expectedOutput({ 0, 0, 0, 0,  1, 1, 1, 1,
 124                                                 0, 0, 0, 0,  0, 0, 0, 0 });
 125
 126     ComparisonSimpleEndToEnd<armnn::DataType::Float32>(defaultBackends,
 127                                                        ComparisonOperation::Greater,
 128                                                        expectedOutput);
 129 }
 130
 131 BOOST_AUTO_TEST_CASE(ClGreaterSimpleEndToEndUint8Test)
 132 {
 133     const std::vector<uint8_t> expectedOutput({ 0, 0, 0, 0,  1, 1, 1, 1,
 134                                                 0, 0, 0, 0,  0, 0, 0, 0 });
 135
 136     ComparisonSimpleEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends,
 137                                                                ComparisonOperation::Greater,
 138                                                                expectedOutput);
 139 }
 140
 141 BOOST_AUTO_TEST_CASE(ClGreaterBroadcastEndToEndTest)
 142 {
 143     const std::vector<uint8_t> expectedOutput({ 0, 1, 0, 0, 0, 1,
 144                                                 1, 1, 1, 1, 1, 1 });
 145
 146     ComparisonBroadcastEndToEnd<armnn::DataType::Float32>(defaultBackends,
 147                                                           ComparisonOperation::Greater,
 148                                                           expectedOutput);
 149 }
 150
 151 BOOST_AUTO_TEST_CASE(ClGreaterBroadcastEndToEndUint8Test)
 152 {
 153     const std::vector<uint8_t> expectedOutput({ 0, 1, 0, 0, 0, 1,
 154                                                 1, 1, 1, 1, 1, 1 });
 155
 156     ComparisonBroadcastEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends,
 157                                                                   ComparisonOperation::Greater,
 158                                                                   expectedOutput);
 159 }
 160
 161 // InstanceNormalization
 162 BOOST_AUTO_TEST_CASE(ClInstanceNormalizationNhwcEndToEndTest1)
 163 {
 164     InstanceNormalizationNhwcEndToEndTest1(defaultBackends);
 165 }
 166
 167 BOOST_AUTO_TEST_CASE(ClInstanceNormalizationNchwEndToEndTest1)
 168 {
 169     InstanceNormalizationNchwEndToEndTest1(defaultBackends);
 170 }
 171
 172 BOOST_AUTO_TEST_CASE(ClInstanceNormalizationNhwcEndToEndTest2)
 173 {
 174     InstanceNormalizationNhwcEndToEndTest2(defaultBackends);
 175 }
 176
 177 BOOST_AUTO_TEST_CASE(ClInstanceNormalizationNchwEndToEndTest2)
 178 {
 179     InstanceNormalizationNchwEndToEndTest2(defaultBackends);
 180 }
 181
 182 BOOST_AUTO_TEST_CASE(ClPreluEndToEndFloat32Test)
 183 {
 184     PreluEndToEndNegativeTest<armnn::DataType::Float32>(defaultBackends);
 185 }
 186
 187 BOOST_AUTO_TEST_CASE(ClPreluEndToEndTestUint8)
 188 {
 189     PreluEndToEndPositiveTest<armnn::DataType::QAsymmU8>(defaultBackends);
 190 }
 191
 192 BOOST_AUTO_TEST_CASE(ClSpaceToDepthNhwcEndToEndTest1)
 193 {
 194     SpaceToDepthNhwcEndToEndTest1(defaultBackends);
 195 }
 196
 197 BOOST_AUTO_TEST_CASE(ClSpaceToDepthNchwEndToEndTest1)
 198 {
 199     SpaceToDepthNchwEndToEndTest1(defaultBackends);
 200 }
 201
 202 BOOST_AUTO_TEST_CASE(ClSpaceToDepthNhwcEndToEndTest2)
 203 {
 204     SpaceToDepthNhwcEndToEndTest2(defaultBackends);
 205 }
 206
 207 BOOST_AUTO_TEST_CASE(ClSpaceToDepthNchwEndToEndTest2)
 208 {
 209     SpaceToDepthNchwEndToEndTest2(defaultBackends);
 210 }
 211
 212 BOOST_AUTO_TEST_CASE(ClSplitter1dEndToEndTest)
 213 {
 214     Splitter1dEndToEnd<armnn::DataType::Float32>(defaultBackends);
 215 }
 216
 217 BOOST_AUTO_TEST_CASE(ClSplitter1dEndToEndUint8Test)
 218 {
 219     Splitter1dEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
 220 }
 221
 222 BOOST_AUTO_TEST_CASE(ClSplitter2dDim0EndToEndTest)
 223 {
 224     Splitter2dDim0EndToEnd<armnn::DataType::Float32>(defaultBackends);
 225 }
 226
 227 BOOST_AUTO_TEST_CASE(ClSplitter2dDim1EndToEndTest)
 228 {
 229     Splitter2dDim1EndToEnd<armnn::DataType::Float32>(defaultBackends);
 230 }
 231
 232 BOOST_AUTO_TEST_CASE(ClSplitter2dDim0EndToEndUint8Test)
 233 {
 234     Splitter2dDim0EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
 235 }
 236
 237 BOOST_AUTO_TEST_CASE(ClSplitter2dDim1EndToEndUint8Test)
 238 {
 239     Splitter2dDim1EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
 240 }
 241
 242 BOOST_AUTO_TEST_CASE(ClSplitter3dDim0EndToEndTest)
 243 {
 244     Splitter3dDim0EndToEnd<armnn::DataType::Float32>(defaultBackends);
 245 }
 246
 247 BOOST_AUTO_TEST_CASE(ClSplitter3dDim1EndToEndTest)
 248 {
 249     Splitter3dDim1EndToEnd<armnn::DataType::Float32>(defaultBackends);
 250 }
 251
 252 BOOST_AUTO_TEST_CASE(ClSplitter3dDim2EndToEndTest)
 253 {
 254     Splitter3dDim2EndToEnd<armnn::DataType::Float32>(defaultBackends);
 255 }
 256
 257 BOOST_AUTO_TEST_CASE(ClSplitter3dDim0EndToEndUint8Test)
 258 {
 259     Splitter3dDim0EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
 260 }
 261
 262 BOOST_AUTO_TEST_CASE(ClSplitter3dDim1EndToEndUint8Test)
 263 {
 264     Splitter3dDim1EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
 265 }
 266
 267 BOOST_AUTO_TEST_CASE(ClSplitter3dDim2EndToEndUint8Test)
 268 {
 269     Splitter3dDim2EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
 270 }
 271
 272 BOOST_AUTO_TEST_CASE(ClSplitter4dDim0EndToEndTest)
 273 {
 274     Splitter4dDim0EndToEnd<armnn::DataType::Float32>(defaultBackends);
 275 }
 276
 277 BOOST_AUTO_TEST_CASE(ClSplitter4dDim1EndToEndTest)
 278 {
 279     Splitter4dDim1EndToEnd<armnn::DataType::Float32>(defaultBackends);
 280 }
 281
 282 BOOST_AUTO_TEST_CASE(ClSplitter4dDim2EndToEndTest)
 283 {
 284     Splitter4dDim2EndToEnd<armnn::DataType::Float32>(defaultBackends);
 285 }
 286
 287 BOOST_AUTO_TEST_CASE(ClSplitter4dDim3EndToEndTest)
 288 {
 289     Splitter4dDim3EndToEnd<armnn::DataType::Float32>(defaultBackends);
 290 }
 291
 292 BOOST_AUTO_TEST_CASE(ClSplitter4dDim0EndToEndUint8Test)
 293 {
 294     Splitter4dDim0EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
 295 }
 296
 297 BOOST_AUTO_TEST_CASE(ClSplitter4dDim1EndToEndUint8Test)
 298 {
 299     Splitter4dDim1EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
 300 }
 301
 302 BOOST_AUTO_TEST_CASE(ClSplitter4dDim2EndToEndUint8Test)
 303 {
 304     Splitter4dDim2EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
 305 }
 306
 307 BOOST_AUTO_TEST_CASE(ClSplitter4dDim3EndToEndUint8Test)
 308 {
 309     Splitter4dDim3EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
 310 }
 311
 312 // TransposeConvolution2d
 313 BOOST_AUTO_TEST_CASE(ClTransposeConvolution2dEndToEndFloatNchwTest)
 314 {
 315     TransposeConvolution2dEndToEnd<armnn::DataType::Float32, armnn::DataType::Float32>(
 316         defaultBackends, armnn::DataLayout::NCHW);
 317 }
 318
 319 BOOST_AUTO_TEST_CASE(ClTransposeConvolution2dEndToEndUint8NchwTest)
 320 {
 321     TransposeConvolution2dEndToEnd<armnn::DataType::QAsymmU8, armnn::DataType::Signed32>(
 322         defaultBackends, armnn::DataLayout::NCHW);
 323 }
 324
 325 BOOST_AUTO_TEST_CASE(ClTransposeConvolution2dEndToEndFloatNhwcTest)
 326 {
 327     TransposeConvolution2dEndToEnd<armnn::DataType::Float32, armnn::DataType::Float32>(
 328         defaultBackends, armnn::DataLayout::NHWC);
 329 }
 330
 331 BOOST_AUTO_TEST_CASE(ClTransposeConvolution2dEndToEndUint8NhwcTest)
 332 {
 333     TransposeConvolution2dEndToEnd<armnn::DataType::QAsymmU8, armnn::DataType::Signed32>(
 334         defaultBackends, armnn::DataLayout::NHWC);
 335 }
 336
 337 BOOST_AUTO_TEST_CASE(ClQuantizedLstmEndToEndTest)
 338 {
 339     QuantizedLstmEndToEnd(defaultBackends);
 340 }
 341
 342 // ArgMinMax
 343 BOOST_AUTO_TEST_CASE(ClArgMaxSimpleTest)
 344 {
 345     ArgMaxEndToEndSimple<armnn::DataType::Float32>(defaultBackends);
 346 }
 347
 348 BOOST_AUTO_TEST_CASE(ClArgMinSimpleTest)
 349 {
 350     ArgMinEndToEndSimple<armnn::DataType::Float32>(defaultBackends);
 351 }
 352
 353 BOOST_AUTO_TEST_CASE(ClArgMaxAxis0Test)
 354 {
 355     ArgMaxAxis0EndToEnd<armnn::DataType::Float32>(defaultBackends);
 356 }
 357
 358 BOOST_AUTO_TEST_CASE(ClArgMinAxis0Test)
 359 {
 360     ArgMinAxis0EndToEnd<armnn::DataType::Float32>(defaultBackends);
 361 }
 362
 363 BOOST_AUTO_TEST_CASE(ClArgMaxAxis1Test)
 364 {
 365     ArgMaxAxis1EndToEnd<armnn::DataType::Float32>(defaultBackends);
 366 }
 367
 368 BOOST_AUTO_TEST_CASE(ClArgMinAxis1Test)
 369 {
 370     ArgMinAxis1EndToEnd<armnn::DataType::Float32>(defaultBackends);
 371 }
 372
 373 BOOST_AUTO_TEST_CASE(ClArgMaxAxis2Test)
 374 {
 375     ArgMaxAxis2EndToEnd<armnn::DataType::Float32>(defaultBackends);
 376 }
 377
 378 BOOST_AUTO_TEST_CASE(ClArgMinAxis2Test)
 379 {
 380     ArgMinAxis2EndToEnd<armnn::DataType::Float32>(defaultBackends);
 381 }
 382
 383 BOOST_AUTO_TEST_CASE(ClArgMaxAxis3Test)
 384 {
 385     ArgMaxAxis3EndToEnd<armnn::DataType::Float32>(defaultBackends);
 386 }
 387
 388 BOOST_AUTO_TEST_CASE(ClArgMinAxis3Test)
 389 {
 390     ArgMinAxis3EndToEnd<armnn::DataType::Float32>(defaultBackends);
 391 }
 392
 393 BOOST_AUTO_TEST_SUITE_END()