1 // 2 // Copyright © 2017-2023 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/AdditionEndToEndTestImpl.hpp> 10 #include <backendsCommon/test/ArgMinMaxEndToEndTestImpl.hpp> 11 #include <backendsCommon/test/ComparisonEndToEndTestImpl.hpp> 12 #include <backendsCommon/test/ConcatEndToEndTestImpl.hpp> 13 #include <backendsCommon/test/DepthToSpaceEndToEndTestImpl.hpp> 14 #include <backendsCommon/test/DequantizeEndToEndTestImpl.hpp> 15 #include <backendsCommon/test/ElementwiseUnaryEndToEndTestImpl.hpp> 16 #include <backendsCommon/test/FillEndToEndTestImpl.hpp> 17 #include <backendsCommon/test/InstanceNormalizationEndToEndTestImpl.hpp> 18 #include <backendsCommon/test/PreluEndToEndTestImpl.hpp> 19 #include <backendsCommon/test/QLstmEndToEndTestImpl.hpp> 20 #include <backendsCommon/test/QuantizedLstmEndToEndTestImpl.hpp> 21 #include <backendsCommon/test/ReduceEndToEndTestImpl.hpp> 22 #include <backendsCommon/test/ReshapeEndToEndTestImpl.hpp> 23 #include <backendsCommon/test/SpaceToDepthEndToEndTestImpl.hpp> 24 #include <backendsCommon/test/SplitterEndToEndTestImpl.hpp> 25 #include <backendsCommon/test/TransposeConvolution2dEndToEndTestImpl.hpp> 26 #include <backendsCommon/test/TransposeEndToEndTestImpl.hpp> 27 28 #include <doctest/doctest.h> 29 30 TEST_SUITE("ClEndToEnd") 31 { 32 std::vector<armnn::BackendId> clDefaultBackends = {armnn::Compute::GpuAcc}; 33 34 // ElementwiseUnary 35 // Abs 36 TEST_CASE("ClAbsEndToEndTestFloat32") 37 { 38 ElementwiseUnarySimpleEndToEnd<armnn::DataType::Float32>(clDefaultBackends, 39 UnaryOperation::Abs); 40 } 41 // Rsqrt 42 TEST_CASE("ClRsqrtEndToEndTestFloat32") 43 { 44 ElementwiseUnarySimpleEndToEnd<armnn::DataType::Float32>(clDefaultBackends, 45 UnaryOperation::Rsqrt); 46 } 47 48 // Addition 49 TEST_CASE("ClAdditionEndToEndFloat32Test") 50 { 51 AdditionEndToEnd<armnn::DataType::Float32>(clDefaultBackends); 52 } 53 54 TEST_CASE("ClAdditionEndToEndUint8Test") 55 { 56 AdditionEndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends); 57 } 58 59 // Constant 60 TEST_CASE("ConstantUsage_Cl_Float32") 61 { 62 ConstantUsageFloat32Test(clDefaultBackends); 63 } 64 65 TEST_CASE("ClConcatEndToEndDim0Test") 66 { 67 ConcatDim0EndToEnd<armnn::DataType::Float32>(clDefaultBackends); 68 } 69 70 TEST_CASE("ClConcatEndToEndDim0Uint8Test") 71 { 72 ConcatDim0EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends); 73 } 74 75 TEST_CASE("ClConcatEndToEndDim1Test") 76 { 77 ConcatDim1EndToEnd<armnn::DataType::Float32>(clDefaultBackends); 78 } 79 80 TEST_CASE("ClConcatEndToEndDim1Uint8Test") 81 { 82 ConcatDim1EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends); 83 } 84 85 TEST_CASE("ClConcatEndToEndDim3Test") 86 { 87 ConcatDim3EndToEnd<armnn::DataType::Float32>(clDefaultBackends); 88 } 89 90 TEST_CASE("ClConcatEndToEndDim3Uint8Test") 91 { 92 ConcatDim3EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends); 93 } 94 95 // DepthToSpace 96 TEST_CASE("DephtToSpaceEndToEndNchwFloat32") 97 { 98 DepthToSpaceEndToEnd<armnn::DataType::Float32>(clDefaultBackends, armnn::DataLayout::NCHW); 99 } 100 101 TEST_CASE("DephtToSpaceEndToEndNchwFloat16") 102 { 103 DepthToSpaceEndToEnd<armnn::DataType::Float16>(clDefaultBackends, armnn::DataLayout::NCHW); 104 } 105 106 TEST_CASE("DephtToSpaceEndToEndNchwUint8") 107 { 108 DepthToSpaceEndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends, armnn::DataLayout::NCHW); 109 } 110 111 TEST_CASE("DephtToSpaceEndToEndNchwInt16") 112 { 113 DepthToSpaceEndToEnd<armnn::DataType::QSymmS16>(clDefaultBackends, armnn::DataLayout::NCHW); 114 } 115 116 TEST_CASE("DephtToSpaceEndToEndNhwcFloat32") 117 { 118 DepthToSpaceEndToEnd<armnn::DataType::Float32>(clDefaultBackends, armnn::DataLayout::NHWC); 119 } 120 121 TEST_CASE("DephtToSpaceEndToEndNhwcFloat16") 122 { 123 DepthToSpaceEndToEnd<armnn::DataType::Float16>(clDefaultBackends, armnn::DataLayout::NHWC); 124 } 125 126 TEST_CASE("DephtToSpaceEndToEndNhwcUint8") 127 { 128 DepthToSpaceEndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends, armnn::DataLayout::NHWC); 129 } 130 131 TEST_CASE("DephtToSpaceEndToEndNhwcInt16") 132 { 133 DepthToSpaceEndToEnd<armnn::DataType::QSymmS16>(clDefaultBackends, armnn::DataLayout::NHWC); 134 } 135 136 // Dequantize 137 TEST_CASE("DequantizeEndToEndSimpleTest") 138 { 139 DequantizeEndToEndSimple<armnn::DataType::QAsymmU8>(clDefaultBackends); 140 } 141 142 TEST_CASE("DequantizeEndToEndOffsetTest") 143 { 144 DequantizeEndToEndOffset<armnn::DataType::QAsymmU8>(clDefaultBackends); 145 } 146 147 TEST_CASE("ClStridedSliceInvalidSliceEndToEndTest") 148 { 149 StridedSliceInvalidSliceEndToEndTest(clDefaultBackends); 150 } 151 152 TEST_CASE("ClEluEndToEndTestFloat32") 153 { 154 EluEndToEndTest<armnn::DataType::Float32>(clDefaultBackends); 155 } 156 157 TEST_CASE("ClEluEndToEndTestFloat16") 158 { 159 EluEndToEndTest<armnn::DataType::Float16>(clDefaultBackends); 160 } 161 162 TEST_CASE("ClGreaterSimpleEndToEndTest") 163 { 164 const std::vector<uint8_t> expectedOutput({ 0, 0, 0, 0, 1, 1, 1, 1, 165 0, 0, 0, 0, 0, 0, 0, 0 }); 166 167 ComparisonSimpleEndToEnd<armnn::DataType::Float32>(clDefaultBackends, 168 ComparisonOperation::Greater, 169 expectedOutput); 170 } 171 172 TEST_CASE("ClGreaterSimpleEndToEndUint8Test") 173 { 174 const std::vector<uint8_t> expectedOutput({ 0, 0, 0, 0, 1, 1, 1, 1, 175 0, 0, 0, 0, 0, 0, 0, 0 }); 176 177 ComparisonSimpleEndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends, 178 ComparisonOperation::Greater, 179 expectedOutput); 180 } 181 182 TEST_CASE("ClGreaterBroadcastEndToEndTest") 183 { 184 const std::vector<uint8_t> expectedOutput({ 0, 1, 0, 0, 0, 1, 185 1, 1, 1, 1, 1, 1 }); 186 187 ComparisonBroadcastEndToEnd<armnn::DataType::Float32>(clDefaultBackends, 188 ComparisonOperation::Greater, 189 expectedOutput); 190 } 191 192 TEST_CASE("ClGreaterBroadcastEndToEndUint8Test") 193 { 194 const std::vector<uint8_t> expectedOutput({ 0, 1, 0, 0, 0, 1, 195 1, 1, 1, 1, 1, 1 }); 196 197 ComparisonBroadcastEndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends, 198 ComparisonOperation::Greater, 199 expectedOutput); 200 } 201 202 // HardSwish 203 TEST_CASE("ClHardSwishEndToEndTestFloat32") 204 { 205 HardSwishEndToEndTest<armnn::DataType::Float32>(clDefaultBackends); 206 } 207 208 TEST_CASE("ClHardSwishEndToEndTestFloat16") 209 { 210 HardSwishEndToEndTest<armnn::DataType::Float16>(clDefaultBackends); 211 } 212 213 TEST_CASE("ClHardSwishEndToEndTestQAsymmS8") 214 { 215 HardSwishEndToEndTest<armnn::DataType::QAsymmS8>(clDefaultBackends); 216 } 217 218 TEST_CASE("ClHardSwishEndToEndTestQAsymmU8") 219 { 220 HardSwishEndToEndTest<armnn::DataType::QAsymmU8>(clDefaultBackends); 221 } 222 223 TEST_CASE("ClHardSwishEndToEndTestQSymmS16") 224 { 225 HardSwishEndToEndTest<armnn::DataType::QSymmS16>(clDefaultBackends); 226 } 227 228 // InstanceNormalization 229 TEST_CASE("ClInstanceNormalizationNhwcEndToEndTest1") 230 { 231 InstanceNormalizationNhwcEndToEndTest1(clDefaultBackends); 232 } 233 234 TEST_CASE("ClInstanceNormalizationNchwEndToEndTest1") 235 { 236 InstanceNormalizationNchwEndToEndTest1(clDefaultBackends); 237 } 238 239 TEST_CASE("ClInstanceNormalizationNhwcEndToEndTest2") 240 { 241 InstanceNormalizationNhwcEndToEndTest2(clDefaultBackends); 242 } 243 244 TEST_CASE("ClInstanceNormalizationNchwEndToEndTest2") 245 { 246 InstanceNormalizationNchwEndToEndTest2(clDefaultBackends); 247 } 248 249 // Fill 250 TEST_CASE("ClFillEndToEndTest") 251 { 252 FillEndToEnd<armnn::DataType::Float32>(clDefaultBackends); 253 } 254 255 TEST_CASE("RefFillEndToEndTestFloat16") 256 { 257 FillEndToEnd<armnn::DataType::Float16>(clDefaultBackends); 258 } 259 260 TEST_CASE("ClFillEndToEndTestInt32") 261 { 262 FillEndToEnd<armnn::DataType::Signed32>(clDefaultBackends); 263 } 264 265 // Prelu 266 TEST_CASE("ClPreluEndToEndFloat32Test") 267 { 268 PreluEndToEndNegativeTest<armnn::DataType::Float32>(clDefaultBackends); 269 } 270 271 TEST_CASE("ClPreluEndToEndTestUint8") 272 { 273 PreluEndToEndPositiveTest<armnn::DataType::QAsymmU8>(clDefaultBackends); 274 } 275 276 // Reduce 277 TEST_CASE("ClReduceEndToEndTest") 278 { 279 ReduceEndToEnd<armnn::DataType::Float32>(clDefaultBackends); 280 } 281 282 TEST_CASE("ClReduceEndToEndTestFloat16") 283 { 284 ReduceEndToEnd<armnn::DataType::Float16>(clDefaultBackends); 285 } 286 287 // Reshape 288 TEST_CASE("ClReshapeEndToEndTest") 289 { 290 ReshapeEndToEnd<armnn::DataType::Float32>(clDefaultBackends); 291 } 292 293 TEST_CASE("ClReshapeEndToEndTestFloat16") 294 { 295 ReshapeEndToEndFloat16<armnn::DataType::Float16>(clDefaultBackends); 296 } 297 298 // Space to depth 299 TEST_CASE("ClSpaceToDepthNhwcEndToEndTest1") 300 { 301 SpaceToDepthNhwcEndToEndTest1(clDefaultBackends); 302 } 303 304 TEST_CASE("ClSpaceToDepthNchwEndToEndTest1") 305 { 306 SpaceToDepthNchwEndToEndTest1(clDefaultBackends); 307 } 308 309 TEST_CASE("ClSpaceToDepthNhwcEndToEndTest2") 310 { 311 SpaceToDepthNhwcEndToEndTest2(clDefaultBackends); 312 } 313 314 TEST_CASE("ClSpaceToDepthNchwEndToEndTest2") 315 { 316 SpaceToDepthNchwEndToEndTest2(clDefaultBackends); 317 } 318 319 // Split 320 TEST_CASE("ClSplitter1dEndToEndTest") 321 { 322 Splitter1dEndToEnd<armnn::DataType::Float32>(clDefaultBackends); 323 } 324 325 TEST_CASE("ClSplitter1dEndToEndUint8Test") 326 { 327 Splitter1dEndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends); 328 } 329 330 TEST_CASE("ClSplitter2dDim0EndToEndTest") 331 { 332 Splitter2dDim0EndToEnd<armnn::DataType::Float32>(clDefaultBackends); 333 } 334 335 TEST_CASE("ClSplitter2dDim1EndToEndTest") 336 { 337 Splitter2dDim1EndToEnd<armnn::DataType::Float32>(clDefaultBackends); 338 } 339 340 TEST_CASE("ClSplitter2dDim0EndToEndUint8Test") 341 { 342 Splitter2dDim0EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends); 343 } 344 345 TEST_CASE("ClSplitter2dDim1EndToEndUint8Test") 346 { 347 Splitter2dDim1EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends); 348 } 349 350 TEST_CASE("ClSplitter3dDim0EndToEndTest") 351 { 352 Splitter3dDim0EndToEnd<armnn::DataType::Float32>(clDefaultBackends); 353 } 354 355 TEST_CASE("ClSplitter3dDim1EndToEndTest") 356 { 357 Splitter3dDim1EndToEnd<armnn::DataType::Float32>(clDefaultBackends); 358 } 359 360 TEST_CASE("ClSplitter3dDim2EndToEndTest") 361 { 362 Splitter3dDim2EndToEnd<armnn::DataType::Float32>(clDefaultBackends); 363 } 364 365 TEST_CASE("ClSplitter3dDim0EndToEndUint8Test") 366 { 367 Splitter3dDim0EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends); 368 } 369 370 TEST_CASE("ClSplitter3dDim1EndToEndUint8Test") 371 { 372 Splitter3dDim1EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends); 373 } 374 375 TEST_CASE("ClSplitter3dDim2EndToEndUint8Test") 376 { 377 Splitter3dDim2EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends); 378 } 379 380 TEST_CASE("ClSplitter4dDim0EndToEndTest") 381 { 382 Splitter4dDim0EndToEnd<armnn::DataType::Float32>(clDefaultBackends); 383 } 384 385 TEST_CASE("ClSplitter4dDim1EndToEndTest") 386 { 387 Splitter4dDim1EndToEnd<armnn::DataType::Float32>(clDefaultBackends); 388 } 389 390 TEST_CASE("ClSplitter4dDim2EndToEndTest") 391 { 392 Splitter4dDim2EndToEnd<armnn::DataType::Float32>(clDefaultBackends); 393 } 394 395 TEST_CASE("ClSplitter4dDim3EndToEndTest") 396 { 397 Splitter4dDim3EndToEnd<armnn::DataType::Float32>(clDefaultBackends); 398 } 399 400 TEST_CASE("ClSplitter4dDim0EndToEndUint8Test") 401 { 402 Splitter4dDim0EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends); 403 } 404 405 TEST_CASE("ClSplitter4dDim1EndToEndUint8Test") 406 { 407 Splitter4dDim1EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends); 408 } 409 410 TEST_CASE("ClSplitter4dDim2EndToEndUint8Test") 411 { 412 Splitter4dDim2EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends); 413 } 414 415 TEST_CASE("ClSplitter4dDim3EndToEndUint8Test") 416 { 417 Splitter4dDim3EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends); 418 } 419 420 // TransposeConvolution2d 421 TEST_CASE("ClTransposeConvolution2dEndToEndFloatNchwTest") 422 { 423 TransposeConvolution2dEndToEnd<armnn::DataType::Float32, armnn::DataType::Float32>( 424 clDefaultBackends, armnn::DataLayout::NCHW); 425 } 426 427 TEST_CASE("ClTransposeConvolution2dEndToEndUint8NchwTest") 428 { 429 TransposeConvolution2dEndToEnd<armnn::DataType::QAsymmU8, armnn::DataType::Signed32>( 430 clDefaultBackends, armnn::DataLayout::NCHW); 431 } 432 433 TEST_CASE("ClTransposeConvolution2dEndToEndFloatNhwcTest") 434 { 435 TransposeConvolution2dEndToEnd<armnn::DataType::Float32, armnn::DataType::Float32>( 436 clDefaultBackends, armnn::DataLayout::NHWC); 437 } 438 439 TEST_CASE("ClTransposeConvolution2dEndToEndUint8NhwcTest") 440 { 441 TransposeConvolution2dEndToEnd<armnn::DataType::QAsymmU8, armnn::DataType::Signed32>( 442 clDefaultBackends, armnn::DataLayout::NHWC); 443 } 444 445 // Transpose 446 TEST_CASE("ClTransposeEndToEndTest") 447 { 448 TransposeEndToEnd<armnn::DataType::Float32>(clDefaultBackends); 449 } 450 451 TEST_CASE("ClQuantizedLstmEndToEndTest") 452 { 453 QuantizedLstmEndToEnd(clDefaultBackends); 454 } 455 456 // ArgMinMax 457 TEST_CASE("ClArgMaxSimpleTest") 458 { 459 ArgMaxEndToEndSimple<armnn::DataType::Float32>(clDefaultBackends); 460 } 461 462 TEST_CASE("ClArgMinSimpleTest") 463 { 464 ArgMinEndToEndSimple<armnn::DataType::Float32>(clDefaultBackends); 465 } 466 467 TEST_CASE("ClArgMaxAxis0Test") 468 { 469 ArgMaxAxis0EndToEnd<armnn::DataType::Float32>(clDefaultBackends); 470 } 471 472 TEST_CASE("ClArgMinAxis0Test") 473 { 474 ArgMinAxis0EndToEnd<armnn::DataType::Float32>(clDefaultBackends); 475 } 476 477 TEST_CASE("ClArgMaxAxis1Test") 478 { 479 ArgMaxAxis1EndToEnd<armnn::DataType::Float32>(clDefaultBackends); 480 } 481 482 TEST_CASE("ClArgMinAxis1Test") 483 { 484 ArgMinAxis1EndToEnd<armnn::DataType::Float32>(clDefaultBackends); 485 } 486 487 TEST_CASE("ClArgMaxAxis2Test") 488 { 489 ArgMaxAxis2EndToEnd<armnn::DataType::Float32>(clDefaultBackends); 490 } 491 492 TEST_CASE("ClArgMinAxis2Test") 493 { 494 ArgMinAxis2EndToEnd<armnn::DataType::Float32>(clDefaultBackends); 495 } 496 497 TEST_CASE("ClArgMaxAxis3Test") 498 { 499 ArgMaxAxis3EndToEnd<armnn::DataType::Float32>(clDefaultBackends); 500 } 501 502 TEST_CASE("ClArgMinAxis3Test") 503 { 504 ArgMinAxis3EndToEnd<armnn::DataType::Float32>(clDefaultBackends); 505 } 506 507 TEST_CASE("ClArgMaxSimpleTestQAsymmU8") 508 { 509 ArgMaxEndToEndSimple<armnn::DataType::QAsymmU8>(clDefaultBackends); 510 } 511 512 TEST_CASE("ClArgMinSimpleTestQAsymmU8") 513 { 514 ArgMinEndToEndSimple<armnn::DataType::QAsymmU8>(clDefaultBackends); 515 } 516 517 TEST_CASE("ClArgMaxAxis0TestQAsymmU8") 518 { 519 ArgMaxAxis0EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends); 520 } 521 522 TEST_CASE("ClArgMinAxis0TestQAsymmU8") 523 { 524 ArgMinAxis0EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends); 525 } 526 527 TEST_CASE("ClArgMaxAxis1TestQAsymmU8") 528 { 529 ArgMaxAxis1EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends); 530 } 531 532 TEST_CASE("ClArgMinAxis1TestQAsymmU8") 533 { 534 ArgMinAxis1EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends); 535 } 536 537 TEST_CASE("ClArgMaxAxis2TestQAsymmU8") 538 { 539 ArgMaxAxis2EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends); 540 } 541 542 TEST_CASE("ClArgMinAxis2TestQAsymmU8") 543 { 544 ArgMinAxis2EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends); 545 } 546 547 TEST_CASE("ClArgMaxAxis3TestQAsymmU8") 548 { 549 ArgMaxAxis3EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends); 550 } 551 552 TEST_CASE("ClArgMinAxis3TestQAsymmU8") 553 { 554 ArgMinAxis3EndToEnd<armnn::DataType::QAsymmU8>(clDefaultBackends); 555 } 556 557 TEST_CASE("ClQLstmEndToEndTest") 558 { 559 QLstmEndToEnd(clDefaultBackends); 560 } 561 562 TEST_CASE("ClForceImportWithMisalignedInputBuffersEndToEndTest" 563 // Currently, the CL workload for activation does not support tensor handle replacement so this test case 564 // will always fail. skip(true)565 * doctest::skip(true)) 566 { 567 ForceImportWithMisalignedInputBuffersEndToEndTest(clDefaultBackends); 568 } 569 570 TEST_CASE("ClForceImportWithMisalignedOutputBuffersEndToEndTest" 571 // Currently, the CL workload for activation does not support tensor handle replacement so this test case 572 // will always fail. skip(true)573 * doctest::skip(true)) 574 { 575 ForceImportWithMisalignedOutputBuffersEndToEndTest(clDefaultBackends); 576 } 577 578 TEST_CASE("ClForceImportWithMisalignedInputAndOutputBuffersEndToEndTest") 579 { 580 ForceImportWithMisalignedInputAndOutputBuffersEndToEndTest(clDefaultBackends); 581 } 582 583 } 584