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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
|
//
// Copyright © 2017-2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/backends/Workload.hpp>
#include <aclCommon/ArmComputeTensorUtils.hpp>
#include <neon/NeonTensorHandle.hpp>
#include <neon/NeonTimer.hpp>
#include <armnn/backends/TensorHandle.hpp>
#include <armnn/Utils.hpp>
#include <Half.hpp>
#define ARMNN_SCOPED_PROFILING_EVENT_NEON(name) \
ARMNN_SCOPED_PROFILING_EVENT_WITH_INSTRUMENTS(armnn::Compute::CpuAcc, \
armnn::EmptyOptional(), \
name, \
armnn::NeonTimer(), \
armnn::WallClockTimer())
#define ARMNN_SCOPED_PROFILING_EVENT_NEON_GUID(name, guid) \
ARMNN_SCOPED_PROFILING_EVENT_WITH_INSTRUMENTS(armnn::Compute::CpuAcc, \
guid, \
GetName() + "_" + name, \
armnn::NeonTimer(), \
armnn::WallClockTimer())
/// Creates a profiling event that uses GetGuid() and GetName() from the calling class
#define ARMNN_SCOPED_PROFILING_EVENT_NEON_NAME_GUID(label) \
ARMNN_SCOPED_PROFILING_EVENT_WITH_INSTRUMENTS(armnn::Compute::CpuAcc, \
this->GetGuid(), \
this->GetName() + "_" + label, \
armnn::NeonTimer(), \
armnn::WallClockTimer())
using namespace armnn::armcomputetensorutils;
namespace armnn
{
inline std::string GetConvolutionMethodString(arm_compute::ConvolutionMethod& convolutionMethod)
{
switch (convolutionMethod)
{
case arm_compute::ConvolutionMethod::FFT:
return "FFT";
case arm_compute::ConvolutionMethod::DIRECT:
return "Direct";
case arm_compute::ConvolutionMethod::GEMM:
return "GEMM";
case arm_compute::ConvolutionMethod::WINOGRAD:
return "Winograd";
default:
return "Unknown";
}
}
template <typename T>
void CopyArmComputeTensorData(arm_compute::Tensor& dstTensor, const T* srcData)
{
InitialiseArmComputeTensorEmpty(dstTensor);
CopyArmComputeITensorData(srcData, dstTensor);
}
inline void InitializeArmComputeTensorData(arm_compute::Tensor& tensor,
TensorInfo tensorInfo,
const ITensorHandle* handle)
{
ARMNN_ASSERT(handle);
switch(tensorInfo.GetDataType())
{
case DataType::Float16:
CopyArmComputeTensorData(tensor, reinterpret_cast<const armnn::Half*>(handle->Map()));
break;
case DataType::Float32:
CopyArmComputeTensorData(tensor, reinterpret_cast<const float*>(handle->Map()));
break;
case DataType::QAsymmU8:
CopyArmComputeTensorData(tensor, reinterpret_cast<const uint8_t*>(handle->Map()));
break;
case DataType::QSymmS8:
case DataType::QAsymmS8:
CopyArmComputeTensorData(tensor, reinterpret_cast<const int8_t*>(handle->Map()));
break;
case DataType::Signed32:
CopyArmComputeTensorData(tensor, reinterpret_cast<const int32_t*>(handle->Map()));
break;
case DataType::QSymmS16:
CopyArmComputeTensorData(tensor, reinterpret_cast<const int16_t*>(handle->Map()));
break;
case DataType::BFloat16:
CopyArmComputeTensorData(tensor, reinterpret_cast<const armnn::BFloat16*>(handle->Map()));
break;
default:
// Throw exception; assertion not called in release build.
throw Exception("Unexpected tensor type during InitializeArmComputeTensorData().");
}
};
inline void InitializeArmComputeTensorData(arm_compute::Tensor& tensor,
const ConstTensorHandle* handle)
{
ARMNN_ASSERT(handle);
switch(handle->GetTensorInfo().GetDataType())
{
case DataType::Float16:
CopyArmComputeTensorData(tensor, handle->GetConstTensor<armnn::Half>());
break;
case DataType::Float32:
CopyArmComputeTensorData(tensor, handle->GetConstTensor<float>());
break;
case DataType::QAsymmU8:
CopyArmComputeTensorData(tensor, handle->GetConstTensor<uint8_t>());
break;
case DataType::QSymmS8:
case DataType::QAsymmS8:
CopyArmComputeTensorData(tensor, handle->GetConstTensor<int8_t>());
break;
case DataType::Signed32:
CopyArmComputeTensorData(tensor, handle->GetConstTensor<int32_t>());
break;
case DataType::QSymmS16:
CopyArmComputeTensorData(tensor, handle->GetConstTensor<int16_t>());
break;
case DataType::BFloat16:
CopyArmComputeTensorData(tensor, handle->GetConstTensor<armnn::BFloat16>());
break;
default:
// Throw exception; assertion not called in release build.
throw Exception("Unexpected tensor type during InitializeArmComputeTensorData().");
}
};
inline auto SetNeonStridedSliceData(const std::vector<int>& m_begin,
const std::vector<int>& m_end,
const std::vector<int>& m_stride)
{
arm_compute::Coordinates starts;
arm_compute::Coordinates ends;
arm_compute::Coordinates strides;
unsigned int num_dims = static_cast<unsigned int>(m_begin.size());
for (unsigned int i = 0; i < num_dims; i++)
{
unsigned int revertedIndex = num_dims - i - 1;
starts.set(i, static_cast<int>(m_begin[revertedIndex]));
ends.set(i, static_cast<int>(m_end[revertedIndex]));
strides.set(i, static_cast<int>(m_stride[revertedIndex]));
}
return std::make_tuple(starts, ends, strides);
}
inline auto SetNeonSliceData(const std::vector<unsigned int>& m_begin,
const std::vector<unsigned int>& m_size)
{
// This function must translate the size vector given to an end vector
// expected by the ACL NESlice workload
arm_compute::Coordinates starts;
arm_compute::Coordinates ends;
unsigned int num_dims = static_cast<unsigned int>(m_begin.size());
// For strided slices, we have the relationship size = (end - begin) / stride
// For slice, we assume stride to be a vector of all ones, yielding the formula
// size = (end - begin) therefore we know end = size + begin
for (unsigned int i = 0; i < num_dims; i++)
{
unsigned int revertedIndex = num_dims - i - 1;
starts.set(i, static_cast<int>(m_begin[revertedIndex]));
ends.set(i, static_cast<int>(m_begin[revertedIndex] + m_size[revertedIndex]));
}
return std::make_tuple(starts, ends);
}
template <typename DataType, typename PayloadType>
DataType* GetOutputTensorData(unsigned int idx, const PayloadType& data)
{
ITensorHandle* tensorHandle = data.m_Outputs[idx];
return reinterpret_cast<DataType*>(tensorHandle->Map());
}
} //namespace armnn
|
