src/backends/neon/test/NeonTimerTest.cpp

   1 //
   2 // Copyright © 2017 Arm Ltd. All rights reserved.
   3 // SPDX-License-Identifier: MIT
   4 //
   5
   6 #include <armnn/ArmNN.hpp>
   7
   8 #include <test/TensorHelpers.hpp>
   9
  10 #include <backendsCommon/CpuTensorHandle.hpp>
  11 #include <backendsCommon/WorkloadFactory.hpp>
  12
  13 #include <neon/NeonTimer.hpp>
  14 #include <neon/NeonWorkloadFactory.hpp>
  15
  16 #include <backendsCommon/test/LayerTests.hpp>
  17 #include <backendsCommon/test/TensorCopyUtils.hpp>
  18 #include <backendsCommon/test/WorkloadTestUtils.hpp>
  19
  20 #include <boost/test/unit_test.hpp>
  21
  22 #include <cstdlib>
  23 #include <algorithm>
  24
  25 using namespace armnn;
  26
  27 BOOST_AUTO_TEST_SUITE(NeonTimerInstrument)
  28
  29
  30 BOOST_AUTO_TEST_CASE(NeonTimerGetName)
  31 {
  32     NeonTimer neonTimer;
  33     BOOST_CHECK_EQUAL(neonTimer.GetName(), "NeonKernelTimer");
  34 }
  35
  36 BOOST_AUTO_TEST_CASE(NeonTimerMeasure)
  37 {
  38     NeonWorkloadFactory workloadFactory;
  39
  40     unsigned int inputWidth = 4000u;
  41     unsigned int inputHeight = 5000u;
  42     unsigned int inputChannels = 1u;
  43     unsigned int inputBatchSize = 1u;
  44
  45     float upperBound = 1.0f;
  46     float lowerBound = -1.0f;
  47
  48     size_t inputSize = inputWidth * inputHeight * inputChannels * inputBatchSize;
  49     std::vector<float> inputData(inputSize, 0.f);
  50     std::generate(inputData.begin(), inputData.end(), [](){
  51         return (static_cast<float>(rand()) / static_cast<float>(RAND_MAX / 3)) + 1.f; });
  52
  53     unsigned int outputWidth = inputWidth;
  54     unsigned int outputHeight = inputHeight;
  55     unsigned int outputChannels = inputChannels;
  56     unsigned int outputBatchSize = inputBatchSize;
  57
  58     armnn::TensorInfo inputTensorInfo({ inputBatchSize, inputChannels, inputHeight, inputWidth },
  59         armnn::GetDataType<float>());
  60
  61     armnn::TensorInfo outputTensorInfo({ outputBatchSize, outputChannels, outputHeight, outputWidth },
  62         armnn::GetDataType<float>());
  63
  64     LayerTestResult<float, 4> result(inputTensorInfo);
  65
  66     auto input = MakeTensor<float, 4>(inputTensorInfo, inputData);
  67
  68     std::unique_ptr<armnn::ITensorHandle> inputHandle = workloadFactory.CreateTensorHandle(inputTensorInfo);
  69     std::unique_ptr<armnn::ITensorHandle> outputHandle = workloadFactory.CreateTensorHandle(outputTensorInfo);
  70
  71     // Setup bounded ReLu
  72     armnn::ActivationQueueDescriptor descriptor;
  73     armnn::WorkloadInfo workloadInfo;
  74     AddInputToWorkload(descriptor, workloadInfo, inputTensorInfo, inputHandle.get());
  75     AddOutputToWorkload(descriptor, workloadInfo, outputTensorInfo, outputHandle.get());
  76
  77     descriptor.m_Parameters.m_Function = armnn::ActivationFunction::BoundedReLu;
  78     descriptor.m_Parameters.m_A = upperBound;
  79     descriptor.m_Parameters.m_B = lowerBound;
  80
  81     std::unique_ptr<armnn::IWorkload> workload = workloadFactory.CreateActivation(descriptor, workloadInfo);
  82
  83     inputHandle->Allocate();
  84     outputHandle->Allocate();
  85
  86     CopyDataToITensorHandle(inputHandle.get(), &input[0][0][0][0]);
  87
  88     NeonTimer neonTimer;
  89     // Start the timer.
  90     neonTimer.Start();
  91     // Execute the workload.
  92     workload->Execute();
  93     // Stop the timer.
  94     neonTimer.Stop();
  95
  96     std::vector<Measurement> measurements = neonTimer.GetMeasurements();
  97
  98     BOOST_CHECK_EQUAL(measurements.size(), 2);
  99     BOOST_CHECK_EQUAL(measurements[0].m_Name, "NeonKernelTimer/0: NEFillBorderKernel");
 100     BOOST_CHECK(measurements[0].m_Value > 0.0);
 101     BOOST_CHECK_EQUAL(measurements[1].m_Name, "NeonKernelTimer/1: NEActivationLayerKernel");
 102     BOOST_CHECK(measurements[1].m_Value > 0.0);
 103 }
 104
 105 BOOST_AUTO_TEST_SUITE_END()