src/armnn/test/CreateWorkloadClNeon.hpp

   1 //
   2 // Copyright © 2017 Arm Ltd. All rights reserved.
   3 // See LICENSE file in the project root for full license information.
   4 //
   5 #pragma once
   6
   7 #include "CreateWorkload.hpp"
   8 #include "backends/RefWorkloadFactory.hpp"
   9
  10 #if ARMCOMPUTECL_ENABLED
  11 #include "backends/ClTensorHandle.hpp"
  12 #endif
  13
  14 #if ARMCOMPUTENEON_ENABLED
  15 #include "backends/NeonTensorHandle.hpp"
  16 #endif
  17
  18
  19 using namespace armnn;
  20
  21 namespace
  22 {
  23
  24 using namespace std;
  25
  26 template<typename IComputeTensorHandle>
  27 boost::test_tools::predicate_result CompareTensorHandleShape(IComputeTensorHandle*               tensorHandle,
  28                                                              std::initializer_list<unsigned int> expectedDimensions)
  29 {
  30     arm_compute::ITensorInfo* info = tensorHandle->GetTensor().info();
  31
  32     auto infoNumDims = info->num_dimensions();
  33     auto numExpectedDims = expectedDimensions.size();
  34     if (infoNumDims != numExpectedDims)
  35     {
  36         boost::test_tools::predicate_result res(false);
  37         res.message() << "Different number of dimensions [" << info->num_dimensions()
  38                       << "!=" << expectedDimensions.size() << "]";
  39         return res;
  40     }
  41
  42     size_t i = info->num_dimensions() - 1;
  43
  44     for (unsigned int expectedDimension : expectedDimensions)
  45     {
  46         if (info->dimension(i) != expectedDimension)
  47         {
  48             boost::test_tools::predicate_result res(false);
  49             res.message() << "Different dimension [" << info->dimension(i) << "!=" << expectedDimension << "]";
  50             return res;
  51         }
  52
  53         i--;
  54     }
  55
  56     return true;
  57 }
  58
  59 template<typename IComputeTensorHandle>
  60 void CreateMemCopyWorkloads(IWorkloadFactory& factory)
  61 {
  62     Graph graph;
  63     RefWorkloadFactory refFactory;
  64
  65     // Creates the layers we're testing.
  66     Layer* const layer1 = graph.AddLayer<MemCopyLayer>("layer1");
  67     Layer* const layer2 = graph.AddLayer<MemCopyLayer>("layer2");
  68
  69     // Creates extra layers.
  70     Layer* const input = graph.AddLayer<InputLayer>(0, "input");
  71     Layer* const output = graph.AddLayer<OutputLayer>(0, "output");
  72
  73     // Connects up.
  74     TensorInfo tensorInfo({2, 3}, DataType::Float32);
  75     Connect(input, layer1, tensorInfo);
  76     Connect(layer1, layer2, tensorInfo);
  77     Connect(layer2, output, tensorInfo);
  78
  79     input->CreateTensorHandles(graph, refFactory);
  80     layer1->CreateTensorHandles(graph, factory);
  81     layer2->CreateTensorHandles(graph, refFactory);
  82     output->CreateTensorHandles(graph, refFactory);
  83
  84     // make the workloads and check them
  85     auto workload1 = MakeAndCheckWorkload<CopyMemGenericWorkload>(*layer1, graph, factory);
  86     auto workload2 = MakeAndCheckWorkload<CopyMemGenericWorkload>(*layer2, graph, refFactory);
  87
  88     MemCopyQueueDescriptor queueDescriptor1 = workload1->GetData();
  89     BOOST_TEST(queueDescriptor1.m_Inputs.size() == 1);
  90     BOOST_TEST(queueDescriptor1.m_Outputs.size() == 1);
  91     auto inputHandle1  = boost::polymorphic_downcast<ConstCpuTensorHandle*>(queueDescriptor1.m_Inputs[0]);
  92     auto outputHandle1 = boost::polymorphic_downcast<IComputeTensorHandle*>(queueDescriptor1.m_Outputs[0]);
  93     BOOST_TEST((inputHandle1->GetTensorInfo() == TensorInfo({2, 3}, DataType::Float32)));
  94     BOOST_TEST(CompareTensorHandleShape<IComputeTensorHandle>(outputHandle1, {2, 3}));
  95
  96
  97     MemCopyQueueDescriptor queueDescriptor2 = workload2->GetData();
  98     BOOST_TEST(queueDescriptor2.m_Inputs.size() == 1);
  99     BOOST_TEST(queueDescriptor2.m_Outputs.size() == 1);
 100     auto inputHandle2  = boost::polymorphic_downcast<IComputeTensorHandle*>(queueDescriptor2.m_Inputs[0]);
 101     auto outputHandle2 = boost::polymorphic_downcast<CpuTensorHandle*>(queueDescriptor2.m_Outputs[0]);
 102     BOOST_TEST(CompareTensorHandleShape<IComputeTensorHandle>(inputHandle2, {2, 3}));
 103     BOOST_TEST((outputHandle2->GetTensorInfo() == TensorInfo({2, 3}, DataType::Float32)));
 104 }
 105
 106 } //namespace