telsoa01 | 4fcda01 | 2018-03-09 14:13:49 +0000 | [diff] [blame] | 1 | // |
| 2 | // Copyright © 2017 Arm Ltd. All rights reserved. |
David Beck | ecb56cd | 2018-09-05 12:52:57 +0100 | [diff] [blame] | 3 | // SPDX-License-Identifier: MIT |
telsoa01 | 4fcda01 | 2018-03-09 14:13:49 +0000 | [diff] [blame] | 4 | // |
| 5 | #pragma once |
| 6 | |
Aron Virginas-Tar | c9cc804 | 2018-11-01 16:15:57 +0000 | [diff] [blame] | 7 | #include <test/CreateWorkload.hpp> |
arovir01 | 43095f3 | 2018-10-09 18:04:24 +0100 | [diff] [blame] | 8 | |
Jan Eilers | bb446e5 | 2020-04-02 13:56:54 +0100 | [diff] [blame] | 9 | #include <armnn/utility/PolymorphicDowncast.hpp> |
Aron Virginas-Tar | c9cc804 | 2018-11-01 16:15:57 +0000 | [diff] [blame] | 10 | #include <backendsCommon/MemCopyWorkload.hpp> |
| 11 | #include <reference/RefWorkloadFactory.hpp> |
Matthew Bentham | 4cefc41 | 2019-06-18 16:14:34 +0100 | [diff] [blame] | 12 | #include <reference/RefTensorHandle.hpp> |
telsoa01 | 4fcda01 | 2018-03-09 14:13:49 +0000 | [diff] [blame] | 13 | |
Matteo Martincigh | d95e906 | 2019-01-31 15:35:59 +0000 | [diff] [blame] | 14 | #if defined(ARMCOMPUTECL_ENABLED) |
Aron Virginas-Tar | c9cc804 | 2018-11-01 16:15:57 +0000 | [diff] [blame] | 15 | #include <cl/ClTensorHandle.hpp> |
telsoa01 | 4fcda01 | 2018-03-09 14:13:49 +0000 | [diff] [blame] | 16 | #endif |
| 17 | |
Matteo Martincigh | d95e906 | 2019-01-31 15:35:59 +0000 | [diff] [blame] | 18 | #if defined(ARMCOMPUTENEON_ENABLED) |
Aron Virginas-Tar | c9cc804 | 2018-11-01 16:15:57 +0000 | [diff] [blame] | 19 | #include <neon/NeonTensorHandle.hpp> |
telsoa01 | 4fcda01 | 2018-03-09 14:13:49 +0000 | [diff] [blame] | 20 | #endif |
| 21 | |
telsoa01 | 4fcda01 | 2018-03-09 14:13:49 +0000 | [diff] [blame] | 22 | using namespace armnn; |
| 23 | |
| 24 | namespace |
| 25 | { |
| 26 | |
| 27 | using namespace std; |
| 28 | |
| 29 | template<typename IComputeTensorHandle> |
| 30 | boost::test_tools::predicate_result CompareTensorHandleShape(IComputeTensorHandle* tensorHandle, |
| 31 | std::initializer_list<unsigned int> expectedDimensions) |
| 32 | { |
| 33 | arm_compute::ITensorInfo* info = tensorHandle->GetTensor().info(); |
| 34 | |
| 35 | auto infoNumDims = info->num_dimensions(); |
| 36 | auto numExpectedDims = expectedDimensions.size(); |
| 37 | if (infoNumDims != numExpectedDims) |
| 38 | { |
| 39 | boost::test_tools::predicate_result res(false); |
| 40 | res.message() << "Different number of dimensions [" << info->num_dimensions() |
| 41 | << "!=" << expectedDimensions.size() << "]"; |
| 42 | return res; |
| 43 | } |
| 44 | |
| 45 | size_t i = info->num_dimensions() - 1; |
| 46 | |
| 47 | for (unsigned int expectedDimension : expectedDimensions) |
| 48 | { |
| 49 | if (info->dimension(i) != expectedDimension) |
| 50 | { |
| 51 | boost::test_tools::predicate_result res(false); |
Matthew Bentham | 8910528 | 2018-11-20 14:33:33 +0000 | [diff] [blame] | 52 | res.message() << "For dimension " << i << |
| 53 | " expected size " << expectedDimension << |
| 54 | " got " << info->dimension(i); |
telsoa01 | 4fcda01 | 2018-03-09 14:13:49 +0000 | [diff] [blame] | 55 | return res; |
| 56 | } |
| 57 | |
| 58 | i--; |
| 59 | } |
| 60 | |
| 61 | return true; |
| 62 | } |
| 63 | |
telsoa01 | c577f2c | 2018-08-31 09:22:23 +0100 | [diff] [blame] | 64 | template<typename IComputeTensorHandle> |
telsoa01 | 4fcda01 | 2018-03-09 14:13:49 +0000 | [diff] [blame] | 65 | void CreateMemCopyWorkloads(IWorkloadFactory& factory) |
| 66 | { |
Derek Lamberti | 84da38b | 2019-06-13 11:40:08 +0100 | [diff] [blame] | 67 | TensorHandleFactoryRegistry registry; |
telsoa01 | 4fcda01 | 2018-03-09 14:13:49 +0000 | [diff] [blame] | 68 | Graph graph; |
| 69 | RefWorkloadFactory refFactory; |
| 70 | |
telsoa01 | c577f2c | 2018-08-31 09:22:23 +0100 | [diff] [blame] | 71 | // Creates the layers we're testing. |
telsoa01 | 4fcda01 | 2018-03-09 14:13:49 +0000 | [diff] [blame] | 72 | Layer* const layer1 = graph.AddLayer<MemCopyLayer>("layer1"); |
| 73 | Layer* const layer2 = graph.AddLayer<MemCopyLayer>("layer2"); |
| 74 | |
telsoa01 | c577f2c | 2018-08-31 09:22:23 +0100 | [diff] [blame] | 75 | // Creates extra layers. |
telsoa01 | 4fcda01 | 2018-03-09 14:13:49 +0000 | [diff] [blame] | 76 | Layer* const input = graph.AddLayer<InputLayer>(0, "input"); |
| 77 | Layer* const output = graph.AddLayer<OutputLayer>(0, "output"); |
| 78 | |
telsoa01 | c577f2c | 2018-08-31 09:22:23 +0100 | [diff] [blame] | 79 | // Connects up. |
telsoa01 | 4fcda01 | 2018-03-09 14:13:49 +0000 | [diff] [blame] | 80 | TensorInfo tensorInfo({2, 3}, DataType::Float32); |
| 81 | Connect(input, layer1, tensorInfo); |
| 82 | Connect(layer1, layer2, tensorInfo); |
| 83 | Connect(layer2, output, tensorInfo); |
| 84 | |
Derek Lamberti | 84da38b | 2019-06-13 11:40:08 +0100 | [diff] [blame] | 85 | input->CreateTensorHandles(registry, refFactory); |
| 86 | layer1->CreateTensorHandles(registry, factory); |
| 87 | layer2->CreateTensorHandles(registry, refFactory); |
| 88 | output->CreateTensorHandles(registry, refFactory); |
telsoa01 | 4fcda01 | 2018-03-09 14:13:49 +0000 | [diff] [blame] | 89 | |
| 90 | // make the workloads and check them |
Derek Lamberti | 94a88d2 | 2019-12-10 21:12:59 +0000 | [diff] [blame] | 91 | auto workload1 = MakeAndCheckWorkload<CopyMemGenericWorkload>(*layer1, factory); |
| 92 | auto workload2 = MakeAndCheckWorkload<CopyMemGenericWorkload>(*layer2, refFactory); |
telsoa01 | 4fcda01 | 2018-03-09 14:13:49 +0000 | [diff] [blame] | 93 | |
| 94 | MemCopyQueueDescriptor queueDescriptor1 = workload1->GetData(); |
| 95 | BOOST_TEST(queueDescriptor1.m_Inputs.size() == 1); |
| 96 | BOOST_TEST(queueDescriptor1.m_Outputs.size() == 1); |
Jan Eilers | bb446e5 | 2020-04-02 13:56:54 +0100 | [diff] [blame] | 97 | auto inputHandle1 = PolymorphicDowncast<RefTensorHandle*>(queueDescriptor1.m_Inputs[0]); |
| 98 | auto outputHandle1 = PolymorphicDowncast<IComputeTensorHandle*>(queueDescriptor1.m_Outputs[0]); |
telsoa01 | 4fcda01 | 2018-03-09 14:13:49 +0000 | [diff] [blame] | 99 | BOOST_TEST((inputHandle1->GetTensorInfo() == TensorInfo({2, 3}, DataType::Float32))); |
| 100 | BOOST_TEST(CompareTensorHandleShape<IComputeTensorHandle>(outputHandle1, {2, 3})); |
| 101 | |
| 102 | |
| 103 | MemCopyQueueDescriptor queueDescriptor2 = workload2->GetData(); |
| 104 | BOOST_TEST(queueDescriptor2.m_Inputs.size() == 1); |
| 105 | BOOST_TEST(queueDescriptor2.m_Outputs.size() == 1); |
Jan Eilers | bb446e5 | 2020-04-02 13:56:54 +0100 | [diff] [blame] | 106 | auto inputHandle2 = PolymorphicDowncast<IComputeTensorHandle*>(queueDescriptor2.m_Inputs[0]); |
| 107 | auto outputHandle2 = PolymorphicDowncast<RefTensorHandle*>(queueDescriptor2.m_Outputs[0]); |
telsoa01 | 4fcda01 | 2018-03-09 14:13:49 +0000 | [diff] [blame] | 108 | BOOST_TEST(CompareTensorHandleShape<IComputeTensorHandle>(inputHandle2, {2, 3})); |
| 109 | BOOST_TEST((outputHandle2->GetTensorInfo() == TensorInfo({2, 3}, DataType::Float32))); |
| 110 | } |
| 111 | |
Matthew Bentham | 8910528 | 2018-11-20 14:33:33 +0000 | [diff] [blame] | 112 | } //namespace |