src/backends/neon/test/NeonEndToEndTests.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/ArithmeticTestImpl.hpp>
   9 #include <backendsCommon/test/ConcatTestImpl.hpp>
  10 #include <backendsCommon/test/DequantizeEndToEndTestImpl.hpp>
  11 #include <backendsCommon/test/PreluEndToEndTestImpl.hpp>
  12 #include <backendsCommon/test/QuantizedLstmEndToEndTestImpl.hpp>
  13 #include <backendsCommon/test/SpaceToDepthEndToEndTestImpl.hpp>
  14 #include <backendsCommon/test/SplitterEndToEndTestImpl.hpp>
  15 #include <backendsCommon/test/TransposeConvolution2dEndToEndTestImpl.hpp>
  16
  17 #include <boost/test/unit_test.hpp>
  18
  19 BOOST_AUTO_TEST_SUITE(NeonEndToEnd)
  20
  21 std::vector<armnn::BackendId> defaultBackends = {armnn::Compute::CpuAcc};
  22
  23 BOOST_AUTO_TEST_CASE(ConstantUsage_Neon_Float32)
  24 {
  25     BOOST_TEST(ConstantUsageFloat32Test(defaultBackends));
  26 }
  27
  28 #if defined(ARMNNREF_ENABLED)
  29
  30 // This test unit needs the reference backend, it's not available if the reference backend is not built
  31
  32 BOOST_AUTO_TEST_CASE(FallbackToCpuRef)
  33 {
  34     using namespace armnn;
  35
  36     // Create runtime in which test will run and allow fallback to CpuRef.
  37     IRuntime::CreationOptions options;
  38     IRuntimePtr runtime(IRuntime::Create(options));
  39
  40     // Builds up the structure of the network.
  41     INetworkPtr net(INetwork::Create());
  42
  43     IConnectableLayer* input = net->AddInputLayer(0);
  44
  45     // This layer configuration isn't supported by CpuAcc but we allow fallback to CpuRef so it shoud pass.
  46     NormalizationDescriptor descriptor;
  47     IConnectableLayer* pooling = net->AddNormalizationLayer(descriptor);
  48
  49     IConnectableLayer* output = net->AddOutputLayer(0);
  50
  51     input->GetOutputSlot(0).Connect(pooling->GetInputSlot(0));
  52     pooling->GetOutputSlot(0).Connect(output->GetInputSlot(0));
  53
  54     input->GetOutputSlot(0).SetTensorInfo(TensorInfo({ 1, 1, 4, 4 }, DataType::Float32));
  55     pooling->GetOutputSlot(0).SetTensorInfo(TensorInfo({ 1, 1, 4, 4 }, DataType::Float32));
  56
  57     // optimize the network
  58     std::vector<BackendId> backends = {Compute::CpuAcc, Compute::CpuRef};
  59     IOptimizedNetworkPtr optNet = Optimize(*net, backends, runtime->GetDeviceSpec());
  60
  61     // Load it into the runtime. It should pass.
  62     NetworkId netId;
  63     BOOST_TEST(runtime->LoadNetwork(netId, std::move(optNet)) == Status::Success);
  64 }
  65
  66 #endif
  67
  68 BOOST_AUTO_TEST_CASE(NeonGreaterSimpleEndToEndTest)
  69 {
  70     const std::vector<uint8_t> expectedOutput({ 0, 0, 0, 0,  1, 1, 1, 1,
  71                                                 0, 0, 0, 0,  0, 0, 0, 0 });
  72
  73     ArithmeticSimpleEndToEnd<armnn::DataType::Float32, armnn::DataType::Boolean>(defaultBackends,
  74                                                                                  LayerType::Greater,
  75                                                                                  expectedOutput);
  76 }
  77
  78 BOOST_AUTO_TEST_CASE(NeonGreaterSimpleEndToEndUint8Test)
  79 {
  80     const std::vector<uint8_t> expectedOutput({ 0, 0, 0, 0,  1, 1, 1, 1,
  81                                                 0, 0, 0, 0,  0, 0, 0, 0 });
  82
  83     ArithmeticSimpleEndToEnd<armnn::DataType::QuantisedAsymm8, armnn::DataType::Boolean>(defaultBackends,
  84                                                                                          LayerType::Greater,
  85                                                                                          expectedOutput);
  86 }
  87
  88 BOOST_AUTO_TEST_CASE(NeonGreaterBroadcastEndToEndTest)
  89 {
  90     const std::vector<uint8_t> expectedOutput({ 0, 1, 0, 0, 0, 1,
  91                                                 1, 1, 1, 1, 1, 1 });
  92
  93     ArithmeticBroadcastEndToEnd<armnn::DataType::Float32, armnn::DataType::Boolean>(defaultBackends,
  94                                                                                     LayerType::Greater,
  95                                                                                     expectedOutput);
  96 }
  97
  98 BOOST_AUTO_TEST_CASE(NeonGreaterBroadcastEndToEndUint8Test)
  99 {
 100     const std::vector<uint8_t> expectedOutput({ 0, 1, 0, 0, 0, 1,
 101                                                 1, 1, 1, 1, 1, 1 });
 102
 103     ArithmeticBroadcastEndToEnd<armnn::DataType::QuantisedAsymm8, armnn::DataType::Boolean>(defaultBackends,
 104                                                                                             LayerType::Greater,
 105                                                                                             expectedOutput);
 106 }
 107
 108 BOOST_AUTO_TEST_CASE(NeonConcatEndToEndDim0Test)
 109 {
 110     ConcatDim0EndToEnd<armnn::DataType::Float32>(defaultBackends);
 111 }
 112
 113 BOOST_AUTO_TEST_CASE(NeonConcatEndToEndDim0Uint8Test)
 114 {
 115     ConcatDim0EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
 116 }
 117
 118 BOOST_AUTO_TEST_CASE(NeonConcatEndToEndDim1Test)
 119 {
 120     ConcatDim1EndToEnd<armnn::DataType::Float32>(defaultBackends);
 121 }
 122
 123 BOOST_AUTO_TEST_CASE(NeonConcatEndToEndDim1Uint8Test)
 124 {
 125     ConcatDim1EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
 126 }
 127
 128 BOOST_AUTO_TEST_CASE(NeonConcatEndToEndDim3Test)
 129 {
 130     ConcatDim3EndToEnd<armnn::DataType::Float32>(defaultBackends);
 131 }
 132
 133 BOOST_AUTO_TEST_CASE(NeonConcatEndToEndDim3Uint8Test)
 134 {
 135     ConcatDim3EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
 136 }
 137
 138 BOOST_AUTO_TEST_CASE(DequantizeEndToEndSimpleTest)
 139 {
 140     DequantizeEndToEndSimple<armnn::DataType::QuantisedAsymm8>(defaultBackends);
 141 }
 142
 143 BOOST_AUTO_TEST_CASE(DequantizeEndToEndOffsetTest)
 144 {
 145     DequantizeEndToEndOffset<armnn::DataType::QuantisedAsymm8>(defaultBackends);
 146 }
 147
 148 BOOST_AUTO_TEST_CASE(NeonPreluEndToEndFloat32Test)
 149 {
 150     PreluEndToEndNegativeTest<armnn::DataType::Float32>(defaultBackends);
 151 }
 152
 153 BOOST_AUTO_TEST_CASE(NeonPreluEndToEndTestUint8Test)
 154 {
 155     PreluEndToEndPositiveTest<armnn::DataType::QuantisedAsymm8>(defaultBackends);
 156 }
 157
 158 BOOST_AUTO_TEST_CASE(NeonSpaceToDepthNHWCEndToEndTest1)
 159 {
 160     SpaceToDepthNHWCEndToEndTest1(defaultBackends);
 161 }
 162
 163 BOOST_AUTO_TEST_CASE(NeonSpaceToDepthNCHWEndToEndTest1)
 164 {
 165     SpaceToDepthNCHWEndToEndTest1(defaultBackends);
 166 }
 167
 168 BOOST_AUTO_TEST_CASE(NeonSpaceToDepthNHWCEndToEndTest2)
 169 {
 170     SpaceToDepthNHWCEndToEndTest2(defaultBackends);
 171 }
 172
 173 BOOST_AUTO_TEST_CASE(NeonSpaceToDepthNCHWEndToEndTest2)
 174 {
 175     SpaceToDepthNCHWEndToEndTest2(defaultBackends);
 176 }
 177
 178 BOOST_AUTO_TEST_CASE(NeonSplitter1dEndToEndTest)
 179 {
 180     Splitter1dEndToEnd<armnn::DataType::Float32>(defaultBackends);
 181 }
 182
 183 BOOST_AUTO_TEST_CASE(NeonSplitter1dEndToEndUint8Test)
 184 {
 185     Splitter1dEndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
 186 }
 187
 188 BOOST_AUTO_TEST_CASE(NeonSplitter2dDim0EndToEndTest)
 189 {
 190     Splitter2dDim0EndToEnd<armnn::DataType::Float32>(defaultBackends);
 191 }
 192
 193 BOOST_AUTO_TEST_CASE(NeonSplitter2dDim1EndToEndTest)
 194 {
 195     Splitter2dDim1EndToEnd<armnn::DataType::Float32>(defaultBackends);
 196 }
 197
 198 BOOST_AUTO_TEST_CASE(NeonSplitter2dDim0EndToEndUint8Test)
 199 {
 200     Splitter2dDim0EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
 201 }
 202
 203 BOOST_AUTO_TEST_CASE(NeonSplitter2dDim1EndToEndUint8Test)
 204 {
 205     Splitter2dDim1EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
 206 }
 207
 208 BOOST_AUTO_TEST_CASE(NeonSplitter3dDim0EndToEndTest)
 209 {
 210     Splitter3dDim0EndToEnd<armnn::DataType::Float32>(defaultBackends);
 211 }
 212
 213 BOOST_AUTO_TEST_CASE(NeonSplitter3dDim1EndToEndTest)
 214 {
 215     Splitter3dDim1EndToEnd<armnn::DataType::Float32>(defaultBackends);
 216 }
 217
 218 BOOST_AUTO_TEST_CASE(NeonSplitter3dDim2EndToEndTest)
 219 {
 220     Splitter3dDim2EndToEnd<armnn::DataType::Float32>(defaultBackends);
 221 }
 222
 223 BOOST_AUTO_TEST_CASE(NeonSplitter3dDim0EndToEndUint8Test)
 224 {
 225     Splitter3dDim0EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
 226 }
 227
 228 BOOST_AUTO_TEST_CASE(NeonSplitter3dDim1EndToEndUint8Test)
 229 {
 230     Splitter3dDim1EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
 231 }
 232
 233 BOOST_AUTO_TEST_CASE(NeonSplitter3dDim2EndToEndUint8Test)
 234 {
 235     Splitter3dDim2EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
 236 }
 237
 238 BOOST_AUTO_TEST_CASE(NeonSplitter4dDim0EndToEndTest)
 239 {
 240     Splitter4dDim0EndToEnd<armnn::DataType::Float32>(defaultBackends);
 241 }
 242
 243 BOOST_AUTO_TEST_CASE(NeonSplitter4dDim1EndToEndTest)
 244 {
 245     Splitter4dDim1EndToEnd<armnn::DataType::Float32>(defaultBackends);
 246 }
 247
 248 BOOST_AUTO_TEST_CASE(NeonSplitter4dDim2EndToEndTest)
 249 {
 250     Splitter4dDim2EndToEnd<armnn::DataType::Float32>(defaultBackends);
 251 }
 252
 253 BOOST_AUTO_TEST_CASE(NeonSplitter4dDim3EndToEndTest)
 254 {
 255     Splitter4dDim3EndToEnd<armnn::DataType::Float32>(defaultBackends);
 256 }
 257
 258 BOOST_AUTO_TEST_CASE(NeonSplitter4dDim0EndToEndUint8Test)
 259 {
 260     Splitter4dDim0EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
 261 }
 262
 263 BOOST_AUTO_TEST_CASE(NeonSplitter4dDim1EndToEndUint8Test)
 264 {
 265     Splitter4dDim1EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
 266 }
 267
 268 BOOST_AUTO_TEST_CASE(NeonSplitter4dDim2EndToEndUint8Test)
 269 {
 270     Splitter4dDim2EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
 271 }
 272
 273 BOOST_AUTO_TEST_CASE(NeonSplitter4dDim3EndToEndUint8Test)
 274 {
 275     Splitter4dDim3EndToEnd<armnn::DataType::QuantisedAsymm8>(defaultBackends);
 276 }
 277
 278 BOOST_AUTO_TEST_CASE(NeonQuantizedLstmEndToEndTest)
 279 {
 280     QuantizedLstmEndToEnd(defaultBackends);
 281 }
 282
 283 BOOST_AUTO_TEST_CASE(NeonTransposeConvolution2dEndToEndFloatNchwTest)
 284 {
 285     TransposeConvolution2dEndToEnd<armnn::DataType::Float32, armnn::DataType::Float32>(
 286         defaultBackends, armnn::DataLayout::NCHW);
 287 }
 288
 289 BOOST_AUTO_TEST_CASE(NeonTransposeConvolution2dEndToEndUint8NchwTest)
 290 {
 291     TransposeConvolution2dEndToEnd<armnn::DataType::QuantisedAsymm8, armnn::DataType::Signed32>(
 292         defaultBackends, armnn::DataLayout::NCHW);
 293 }
 294
 295 BOOST_AUTO_TEST_CASE(NeonTransposeConvolution2dEndToEndFloatNhwcTest)
 296 {
 297     TransposeConvolution2dEndToEnd<armnn::DataType::Float32, armnn::DataType::Float32>(
 298         defaultBackends, armnn::DataLayout::NHWC);
 299 }
 300
 301 BOOST_AUTO_TEST_CASE(NeonTransposeConvolution2dEndToEndUint8NhwcTest)
 302 {
 303     TransposeConvolution2dEndToEnd<armnn::DataType::QuantisedAsymm8, armnn::DataType::Signed32>(
 304         defaultBackends, armnn::DataLayout::NHWC);
 305 }
 306
 307 BOOST_AUTO_TEST_SUITE_END()