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/ActivationEndToEndTestImpl.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/ElementwiseUnaryEndToEndTestImpl.hpp>
  15 #include <backendsCommon/test/InstanceNormalizationEndToEndTestImpl.hpp>
  16 #include <backendsCommon/test/PreluEndToEndTestImpl.hpp>
  17 #include <backendsCommon/test/QLstmEndToEndTestImpl.hpp>
  18 #include <backendsCommon/test/QuantizedLstmEndToEndTestImpl.hpp>
  19 #include <backendsCommon/test/SpaceToDepthEndToEndTestImpl.hpp>
  20 #include <backendsCommon/test/SplitterEndToEndTestImpl.hpp>
  21 #include <backendsCommon/test/TransposeConvolution2dEndToEndTestImpl.hpp>
  22
  23 #include <boost/test/unit_test.hpp>
  24
  25 BOOST_AUTO_TEST_SUITE(ClEndToEnd)
  26
  27 std::vector<armnn::BackendId> defaultBackends = {armnn::Compute::GpuAcc};
  28
  29 // Abs
  30 BOOST_AUTO_TEST_CASE(ClAbsEndToEndTestFloat32)
  31 {
  32     std::vector<float> expectedOutput =
  33     {
  34         1.f, 1.f, 1.f, 1.f, 5.f, 5.f, 5.f, 5.f,
  35         3.f, 3.f, 3.f, 3.f, 4.f, 4.f, 4.f, 4.f
  36     };
  37
  38     ElementwiseUnarySimpleEndToEnd<armnn::DataType::Float32>(defaultBackends,
  39                                                              UnaryOperation::Abs,
  40                                                              expectedOutput);
  41 }
  42
  43 // Constant
  44 BOOST_AUTO_TEST_CASE(ConstantUsage_Cl_Float32)
  45 {
  46     ConstantUsageFloat32Test(defaultBackends);
  47 }
  48
  49 BOOST_AUTO_TEST_CASE(ClConcatEndToEndDim0Test)
  50 {
  51     ConcatDim0EndToEnd<armnn::DataType::Float32>(defaultBackends);
  52 }
  53
  54 BOOST_AUTO_TEST_CASE(ClConcatEndToEndDim0Uint8Test)
  55 {
  56     ConcatDim0EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
  57 }
  58
  59 BOOST_AUTO_TEST_CASE(ClConcatEndToEndDim1Test)
  60 {
  61     ConcatDim1EndToEnd<armnn::DataType::Float32>(defaultBackends);
  62 }
  63
  64 BOOST_AUTO_TEST_CASE(ClConcatEndToEndDim1Uint8Test)
  65 {
  66     ConcatDim1EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
  67 }
  68
  69 BOOST_AUTO_TEST_CASE(ClConcatEndToEndDim3Test)
  70 {
  71     ConcatDim3EndToEnd<armnn::DataType::Float32>(defaultBackends);
  72 }
  73
  74 BOOST_AUTO_TEST_CASE(ClConcatEndToEndDim3Uint8Test)
  75 {
  76     ConcatDim3EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
  77 }
  78
  79 // DepthToSpace
  80 BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNchwFloat32)
  81 {
  82     DepthToSpaceEndToEnd<armnn::DataType::Float32>(defaultBackends, armnn::DataLayout::NCHW);
  83 }
  84
  85 BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNchwFloat16)
  86 {
  87     DepthToSpaceEndToEnd<armnn::DataType::Float16>(defaultBackends, armnn::DataLayout::NCHW);
  88 }
  89
  90 BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNchwUint8)
  91 {
  92     DepthToSpaceEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, armnn::DataLayout::NCHW);
  93 }
  94
  95 BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNchwInt16)
  96 {
  97     DepthToSpaceEndToEnd<armnn::DataType::QSymmS16>(defaultBackends, armnn::DataLayout::NCHW);
  98 }
  99
 100 BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNhwcFloat32)
 101 {
 102     DepthToSpaceEndToEnd<armnn::DataType::Float32>(defaultBackends, armnn::DataLayout::NHWC);
 103 }
 104
 105 BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNhwcFloat16)
 106 {
 107     DepthToSpaceEndToEnd<armnn::DataType::Float16>(defaultBackends, armnn::DataLayout::NHWC);
 108 }
 109
 110 BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNhwcUint8)
 111 {
 112     DepthToSpaceEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends, armnn::DataLayout::NHWC);
 113 }
 114
 115 BOOST_AUTO_TEST_CASE(DephtToSpaceEndToEndNhwcInt16)
 116 {
 117     DepthToSpaceEndToEnd<armnn::DataType::QSymmS16>(defaultBackends, armnn::DataLayout::NHWC);
 118 }
 119
 120 // Dequantize
 121 BOOST_AUTO_TEST_CASE(DequantizeEndToEndSimpleTest)
 122 {
 123     DequantizeEndToEndSimple<armnn::DataType::QAsymmU8>(defaultBackends);
 124 }
 125
 126 BOOST_AUTO_TEST_CASE(DequantizeEndToEndOffsetTest)
 127 {
 128     DequantizeEndToEndOffset<armnn::DataType::QAsymmU8>(defaultBackends);
 129 }
 130
 131 BOOST_AUTO_TEST_CASE(ClStridedSliceInvalidSliceEndToEndTest)
 132 {
 133     StridedSliceInvalidSliceEndToEndTest(defaultBackends);
 134 }
 135
 136 BOOST_AUTO_TEST_CASE(ClEluEndToEndTestFloat32)
 137 {
 138     EluEndToEndTest<armnn::DataType::Float32>(defaultBackends);
 139 }
 140
 141 BOOST_AUTO_TEST_CASE(ClEluEndToEndTestFloat16)
 142 {
 143     EluEndToEndTest<armnn::DataType::Float16>(defaultBackends);
 144 }
 145
 146 BOOST_AUTO_TEST_CASE(ClGreaterSimpleEndToEndTest)
 147 {
 148     const std::vector<uint8_t> expectedOutput({ 0, 0, 0, 0,  1, 1, 1, 1,
 149                                                 0, 0, 0, 0,  0, 0, 0, 0 });
 150
 151     ComparisonSimpleEndToEnd<armnn::DataType::Float32>(defaultBackends,
 152                                                        ComparisonOperation::Greater,
 153                                                        expectedOutput);
 154 }
 155
 156 BOOST_AUTO_TEST_CASE(ClGreaterSimpleEndToEndUint8Test)
 157 {
 158     const std::vector<uint8_t> expectedOutput({ 0, 0, 0, 0,  1, 1, 1, 1,
 159                                                 0, 0, 0, 0,  0, 0, 0, 0 });
 160
 161     ComparisonSimpleEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends,
 162                                                                ComparisonOperation::Greater,
 163                                                                expectedOutput);
 164 }
 165
 166 BOOST_AUTO_TEST_CASE(ClGreaterBroadcastEndToEndTest)
 167 {
 168     const std::vector<uint8_t> expectedOutput({ 0, 1, 0, 0, 0, 1,
 169                                                 1, 1, 1, 1, 1, 1 });
 170
 171     ComparisonBroadcastEndToEnd<armnn::DataType::Float32>(defaultBackends,
 172                                                           ComparisonOperation::Greater,
 173                                                           expectedOutput);
 174 }
 175
 176 BOOST_AUTO_TEST_CASE(ClGreaterBroadcastEndToEndUint8Test)
 177 {
 178     const std::vector<uint8_t> expectedOutput({ 0, 1, 0, 0, 0, 1,
 179                                                 1, 1, 1, 1, 1, 1 });
 180
 181     ComparisonBroadcastEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends,
 182                                                                   ComparisonOperation::Greater,
 183                                                                   expectedOutput);
 184 }
 185
 186 // HardSwish
 187 BOOST_AUTO_TEST_CASE(ClHardSwishEndToEndTestFloat32)
 188 {
 189     HardSwishEndToEndTest<armnn::DataType::Float32>(defaultBackends);
 190 }
 191
 192 BOOST_AUTO_TEST_CASE(ClHardSwishEndToEndTestFloat16)
 193 {
 194     HardSwishEndToEndTest<armnn::DataType::Float16>(defaultBackends);
 195 }
 196
 197 BOOST_AUTO_TEST_CASE(ClHardSwishEndToEndTestQAsymmS8)
 198 {
 199     HardSwishEndToEndTest<armnn::DataType::QAsymmS8>(defaultBackends);
 200 }
 201
 202 BOOST_AUTO_TEST_CASE(ClHardSwishEndToEndTestQAsymmU8)
 203 {
 204     HardSwishEndToEndTest<armnn::DataType::QAsymmU8>(defaultBackends);
 205 }
 206
 207 BOOST_AUTO_TEST_CASE(ClHardSwishEndToEndTestQSymmS16)
 208 {
 209     HardSwishEndToEndTest<armnn::DataType::QSymmS16>(defaultBackends);
 210 }
 211
 212 // InstanceNormalization
 213 BOOST_AUTO_TEST_CASE(ClInstanceNormalizationNhwcEndToEndTest1)
 214 {
 215     InstanceNormalizationNhwcEndToEndTest1(defaultBackends);
 216 }
 217
 218 BOOST_AUTO_TEST_CASE(ClInstanceNormalizationNchwEndToEndTest1)
 219 {
 220     InstanceNormalizationNchwEndToEndTest1(defaultBackends);
 221 }
 222
 223 BOOST_AUTO_TEST_CASE(ClInstanceNormalizationNhwcEndToEndTest2)
 224 {
 225     InstanceNormalizationNhwcEndToEndTest2(defaultBackends);
 226 }
 227
 228 BOOST_AUTO_TEST_CASE(ClInstanceNormalizationNchwEndToEndTest2)
 229 {
 230     InstanceNormalizationNchwEndToEndTest2(defaultBackends);
 231 }
 232
 233 BOOST_AUTO_TEST_CASE(ClPreluEndToEndFloat32Test)
 234 {
 235     PreluEndToEndNegativeTest<armnn::DataType::Float32>(defaultBackends);
 236 }
 237
 238 BOOST_AUTO_TEST_CASE(ClPreluEndToEndTestUint8)
 239 {
 240     PreluEndToEndPositiveTest<armnn::DataType::QAsymmU8>(defaultBackends);
 241 }
 242
 243 BOOST_AUTO_TEST_CASE(ClSpaceToDepthNhwcEndToEndTest1)
 244 {
 245     SpaceToDepthNhwcEndToEndTest1(defaultBackends);
 246 }
 247
 248 BOOST_AUTO_TEST_CASE(ClSpaceToDepthNchwEndToEndTest1)
 249 {
 250     SpaceToDepthNchwEndToEndTest1(defaultBackends);
 251 }
 252
 253 BOOST_AUTO_TEST_CASE(ClSpaceToDepthNhwcEndToEndTest2)
 254 {
 255     SpaceToDepthNhwcEndToEndTest2(defaultBackends);
 256 }
 257
 258 BOOST_AUTO_TEST_CASE(ClSpaceToDepthNchwEndToEndTest2)
 259 {
 260     SpaceToDepthNchwEndToEndTest2(defaultBackends);
 261 }
 262
 263 BOOST_AUTO_TEST_CASE(ClSplitter1dEndToEndTest)
 264 {
 265     Splitter1dEndToEnd<armnn::DataType::Float32>(defaultBackends);
 266 }
 267
 268 BOOST_AUTO_TEST_CASE(ClSplitter1dEndToEndUint8Test)
 269 {
 270     Splitter1dEndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
 271 }
 272
 273 BOOST_AUTO_TEST_CASE(ClSplitter2dDim0EndToEndTest)
 274 {
 275     Splitter2dDim0EndToEnd<armnn::DataType::Float32>(defaultBackends);
 276 }
 277
 278 BOOST_AUTO_TEST_CASE(ClSplitter2dDim1EndToEndTest)
 279 {
 280     Splitter2dDim1EndToEnd<armnn::DataType::Float32>(defaultBackends);
 281 }
 282
 283 BOOST_AUTO_TEST_CASE(ClSplitter2dDim0EndToEndUint8Test)
 284 {
 285     Splitter2dDim0EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
 286 }
 287
 288 BOOST_AUTO_TEST_CASE(ClSplitter2dDim1EndToEndUint8Test)
 289 {
 290     Splitter2dDim1EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
 291 }
 292
 293 BOOST_AUTO_TEST_CASE(ClSplitter3dDim0EndToEndTest)
 294 {
 295     Splitter3dDim0EndToEnd<armnn::DataType::Float32>(defaultBackends);
 296 }
 297
 298 BOOST_AUTO_TEST_CASE(ClSplitter3dDim1EndToEndTest)
 299 {
 300     Splitter3dDim1EndToEnd<armnn::DataType::Float32>(defaultBackends);
 301 }
 302
 303 BOOST_AUTO_TEST_CASE(ClSplitter3dDim2EndToEndTest)
 304 {
 305     Splitter3dDim2EndToEnd<armnn::DataType::Float32>(defaultBackends);
 306 }
 307
 308 BOOST_AUTO_TEST_CASE(ClSplitter3dDim0EndToEndUint8Test)
 309 {
 310     Splitter3dDim0EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
 311 }
 312
 313 BOOST_AUTO_TEST_CASE(ClSplitter3dDim1EndToEndUint8Test)
 314 {
 315     Splitter3dDim1EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
 316 }
 317
 318 BOOST_AUTO_TEST_CASE(ClSplitter3dDim2EndToEndUint8Test)
 319 {
 320     Splitter3dDim2EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
 321 }
 322
 323 BOOST_AUTO_TEST_CASE(ClSplitter4dDim0EndToEndTest)
 324 {
 325     Splitter4dDim0EndToEnd<armnn::DataType::Float32>(defaultBackends);
 326 }
 327
 328 BOOST_AUTO_TEST_CASE(ClSplitter4dDim1EndToEndTest)
 329 {
 330     Splitter4dDim1EndToEnd<armnn::DataType::Float32>(defaultBackends);
 331 }
 332
 333 BOOST_AUTO_TEST_CASE(ClSplitter4dDim2EndToEndTest)
 334 {
 335     Splitter4dDim2EndToEnd<armnn::DataType::Float32>(defaultBackends);
 336 }
 337
 338 BOOST_AUTO_TEST_CASE(ClSplitter4dDim3EndToEndTest)
 339 {
 340     Splitter4dDim3EndToEnd<armnn::DataType::Float32>(defaultBackends);
 341 }
 342
 343 BOOST_AUTO_TEST_CASE(ClSplitter4dDim0EndToEndUint8Test)
 344 {
 345     Splitter4dDim0EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
 346 }
 347
 348 BOOST_AUTO_TEST_CASE(ClSplitter4dDim1EndToEndUint8Test)
 349 {
 350     Splitter4dDim1EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
 351 }
 352
 353 BOOST_AUTO_TEST_CASE(ClSplitter4dDim2EndToEndUint8Test)
 354 {
 355     Splitter4dDim2EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
 356 }
 357
 358 BOOST_AUTO_TEST_CASE(ClSplitter4dDim3EndToEndUint8Test)
 359 {
 360     Splitter4dDim3EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
 361 }
 362
 363 // TransposeConvolution2d
 364 BOOST_AUTO_TEST_CASE(ClTransposeConvolution2dEndToEndFloatNchwTest)
 365 {
 366     TransposeConvolution2dEndToEnd<armnn::DataType::Float32, armnn::DataType::Float32>(
 367         defaultBackends, armnn::DataLayout::NCHW);
 368 }
 369
 370 BOOST_AUTO_TEST_CASE(ClTransposeConvolution2dEndToEndUint8NchwTest)
 371 {
 372     TransposeConvolution2dEndToEnd<armnn::DataType::QAsymmU8, armnn::DataType::Signed32>(
 373         defaultBackends, armnn::DataLayout::NCHW);
 374 }
 375
 376 BOOST_AUTO_TEST_CASE(ClTransposeConvolution2dEndToEndFloatNhwcTest)
 377 {
 378     TransposeConvolution2dEndToEnd<armnn::DataType::Float32, armnn::DataType::Float32>(
 379         defaultBackends, armnn::DataLayout::NHWC);
 380 }
 381
 382 BOOST_AUTO_TEST_CASE(ClTransposeConvolution2dEndToEndUint8NhwcTest)
 383 {
 384     TransposeConvolution2dEndToEnd<armnn::DataType::QAsymmU8, armnn::DataType::Signed32>(
 385         defaultBackends, armnn::DataLayout::NHWC);
 386 }
 387
 388 BOOST_AUTO_TEST_CASE(ClQuantizedLstmEndToEndTest)
 389 {
 390     QuantizedLstmEndToEnd(defaultBackends);
 391 }
 392
 393 // ArgMinMax
 394 BOOST_AUTO_TEST_CASE(ClArgMaxSimpleTest)
 395 {
 396     ArgMaxEndToEndSimple<armnn::DataType::Float32>(defaultBackends);
 397 }
 398
 399 BOOST_AUTO_TEST_CASE(ClArgMinSimpleTest)
 400 {
 401     ArgMinEndToEndSimple<armnn::DataType::Float32>(defaultBackends);
 402 }
 403
 404 BOOST_AUTO_TEST_CASE(ClArgMaxAxis0Test)
 405 {
 406     ArgMaxAxis0EndToEnd<armnn::DataType::Float32>(defaultBackends);
 407 }
 408
 409 BOOST_AUTO_TEST_CASE(ClArgMinAxis0Test)
 410 {
 411     ArgMinAxis0EndToEnd<armnn::DataType::Float32>(defaultBackends);
 412 }
 413
 414 BOOST_AUTO_TEST_CASE(ClArgMaxAxis1Test)
 415 {
 416     ArgMaxAxis1EndToEnd<armnn::DataType::Float32>(defaultBackends);
 417 }
 418
 419 BOOST_AUTO_TEST_CASE(ClArgMinAxis1Test)
 420 {
 421     ArgMinAxis1EndToEnd<armnn::DataType::Float32>(defaultBackends);
 422 }
 423
 424 BOOST_AUTO_TEST_CASE(ClArgMaxAxis2Test)
 425 {
 426     ArgMaxAxis2EndToEnd<armnn::DataType::Float32>(defaultBackends);
 427 }
 428
 429 BOOST_AUTO_TEST_CASE(ClArgMinAxis2Test)
 430 {
 431     ArgMinAxis2EndToEnd<armnn::DataType::Float32>(defaultBackends);
 432 }
 433
 434 BOOST_AUTO_TEST_CASE(ClArgMaxAxis3Test)
 435 {
 436     ArgMaxAxis3EndToEnd<armnn::DataType::Float32>(defaultBackends);
 437 }
 438
 439 BOOST_AUTO_TEST_CASE(ClArgMinAxis3Test)
 440 {
 441     ArgMinAxis3EndToEnd<armnn::DataType::Float32>(defaultBackends);
 442 }
 443
 444 BOOST_AUTO_TEST_CASE(ClArgMaxSimpleTestQAsymmU8)
 445 {
 446     ArgMaxEndToEndSimple<armnn::DataType::QAsymmU8>(defaultBackends);
 447 }
 448
 449 BOOST_AUTO_TEST_CASE(ClArgMinSimpleTestQAsymmU8)
 450 {
 451     ArgMinEndToEndSimple<armnn::DataType::QAsymmU8>(defaultBackends);
 452 }
 453
 454 BOOST_AUTO_TEST_CASE(ClArgMaxAxis0TestQAsymmU8)
 455 {
 456     ArgMaxAxis0EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
 457 }
 458
 459 BOOST_AUTO_TEST_CASE(ClArgMinAxis0TestQAsymmU8)
 460 {
 461     ArgMinAxis0EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
 462 }
 463
 464 BOOST_AUTO_TEST_CASE(ClArgMaxAxis1TestQAsymmU8)
 465 {
 466     ArgMaxAxis1EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
 467 }
 468
 469 BOOST_AUTO_TEST_CASE(ClArgMinAxis1TestQAsymmU8)
 470 {
 471     ArgMinAxis1EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
 472 }
 473
 474 BOOST_AUTO_TEST_CASE(ClArgMaxAxis2TestQAsymmU8)
 475 {
 476     ArgMaxAxis2EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
 477 }
 478
 479 BOOST_AUTO_TEST_CASE(ClArgMinAxis2TestQAsymmU8)
 480 {
 481     ArgMinAxis2EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
 482 }
 483
 484 BOOST_AUTO_TEST_CASE(ClArgMaxAxis3TestQAsymmU8)
 485 {
 486     ArgMaxAxis3EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
 487 }
 488
 489 BOOST_AUTO_TEST_CASE(ClArgMinAxis3TestQAsymmU8)
 490 {
 491     ArgMinAxis3EndToEnd<armnn::DataType::QAsymmU8>(defaultBackends);
 492 }
 493
 494 BOOST_AUTO_TEST_CASE(ClQLstmEndToEndTest)
 495 {
 496     QLstmEndToEnd(defaultBackends);
 497 }
 498
 499 BOOST_AUTO_TEST_SUITE_END()