aboutsummaryrefslogtreecommitdiff
path: root/src/backends/reference/workloads/RefComparisonWorkload.cpp
blob: bb8bb04ad303f55294d654ff314ee1972c342729 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//

#include "RefComparisonWorkload.hpp"
#include "ElementwiseFunction.hpp"
#include "RefWorkloadUtils.hpp"
#include "Profiling.hpp"
#include <vector>

namespace armnn {

template <typename Functor, typename ParentDescriptor, typename armnn::StringMapping::Id DebugString>
void RefComparisonWorkload<Functor, ParentDescriptor, DebugString>::Execute() const
{
    ARMNN_SCOPED_PROFILING_EVENT(Compute::CpuRef, StringMapping::Instance().Get(DebugString));
    const TensorInfo& inputInfo0 = GetTensorInfo(m_Data.m_Inputs[0]);
    const TensorInfo& inputInfo1 = GetTensorInfo(m_Data.m_Inputs[1]);
    const TensorInfo& outputInfo = GetTensorInfo(m_Data.m_Outputs[0]);

    const TensorShape& inShape0 = inputInfo0.GetShape();
    const TensorShape& inShape1 = inputInfo1.GetShape();
    const TensorShape& outShape = outputInfo.GetShape();

    switch(inputInfo0.GetDataType())
    {
        case armnn::DataType::QuantisedAsymm8:
        {
            QASymm8Decoder decodeIterator0(GetInputTensorDataU8(0, m_Data),
                                           inputInfo0.GetQuantizationScale(),
                                           inputInfo0.GetQuantizationOffset());

            QASymm8Decoder decodeIterator1(GetInputTensorDataU8(1, m_Data),
                                           inputInfo1.GetQuantizationScale(),
                                           inputInfo1.GetQuantizationOffset());

            BooleanEncoder encodeIterator0(GetOutputTensorDataU8(0, m_Data));

            ElementwiseFunction<Functor, Decoder, ComparisonEncoder>(inShape0,
                                                                     inShape1,
                                                                     outShape,
                                                                     decodeIterator0,
                                                                     decodeIterator1,
                                                                     encodeIterator0);
            break;
        }
        case armnn::DataType::Float32:
        {
            FloatDecoder decodeIterator0(GetInputTensorDataFloat(0, m_Data));
            FloatDecoder decodeIterator1(GetInputTensorDataFloat(1, m_Data));
            BooleanEncoder encodeIterator0(GetOutputTensorDataU8(0, m_Data));

            ElementwiseFunction<Functor, Decoder, ComparisonEncoder>(inShape0,
                                                                     inShape1,
                                                                     outShape,
                                                                     decodeIterator0,
                                                                     decodeIterator1,
                                                                     encodeIterator0);
            break;
        }
        default:
            BOOST_ASSERT_MSG(false, "RefComparisonWorkload: Not supported Data Type!");
            break;
    }
}

}

template class armnn::RefComparisonWorkload<std::equal_to<float>,
                                           armnn::EqualQueueDescriptor,
                                           armnn::StringMapping::RefEqualWorkload_Execute>;

template class armnn::RefComparisonWorkload<std::greater<float>,
                                           armnn::GreaterQueueDescriptor,
                                           armnn::StringMapping::RefGreaterWorkload_Execute>;