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
|
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <Half.hpp>
#include <aclCommon/ArmComputeTensorUtils.hpp>
#include <cl/OpenClTimer.hpp>
#include <backendsCommon/CpuTensorHandle.hpp>
#include <armnn/Utils.hpp>
#include <arm_compute/runtime/CL/CLTensor.h>
#include <arm_compute/runtime/IFunction.h>
#include <sstream>
#define ARMNN_SCOPED_PROFILING_EVENT_CL(name) \
ARMNN_SCOPED_PROFILING_EVENT_WITH_INSTRUMENTS(armnn::Compute::GpuAcc, \
name, \
armnn::OpenClTimer(), \
armnn::WallClockTimer())
namespace armnn
{
template <typename T>
void CopyArmComputeClTensorData(arm_compute::CLTensor& dstTensor, const T* srcData)
{
{
ARMNN_SCOPED_PROFILING_EVENT_CL("MapClTensorForWriting");
dstTensor.map(true);
}
{
ARMNN_SCOPED_PROFILING_EVENT_CL("CopyToClTensor");
armcomputetensorutils::CopyArmComputeITensorData<T>(srcData, dstTensor);
}
dstTensor.unmap();
}
inline auto SetClStridedSliceData(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 SetClSliceData(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);
}
inline void InitializeArmComputeClTensorData(arm_compute::CLTensor& clTensor,
const ConstCpuTensorHandle* handle)
{
BOOST_ASSERT(handle);
armcomputetensorutils::InitialiseArmComputeTensorEmpty(clTensor);
switch(handle->GetTensorInfo().GetDataType())
{
case DataType::Float16:
CopyArmComputeClTensorData(clTensor, handle->GetConstTensor<armnn::Half>());
break;
case DataType::Float32:
CopyArmComputeClTensorData(clTensor, handle->GetConstTensor<float>());
break;
case DataType::QAsymmU8:
CopyArmComputeClTensorData(clTensor, handle->GetConstTensor<uint8_t>());
break;
ARMNN_NO_DEPRECATE_WARN_BEGIN
case DataType::QuantizedSymm8PerAxis:
ARMNN_FALLTHROUGH;
case DataType::QSymmS8:
CopyArmComputeClTensorData(clTensor, handle->GetConstTensor<int8_t>());
break;
ARMNN_NO_DEPRECATE_WARN_END
case DataType::Signed32:
CopyArmComputeClTensorData(clTensor, handle->GetConstTensor<int32_t>());
break;
default:
BOOST_ASSERT_MSG(false, "Unexpected tensor type.");
}
};
inline RuntimeException WrapClError(const cl::Error& clError, const CheckLocation& location)
{
std::stringstream message;
message << "CL error: " << clError.what() << ". Error code: " << clError.err();
return RuntimeException(message.str(), location);
}
inline void RunClFunction(arm_compute::IFunction& function, const CheckLocation& location)
{
try
{
function.run();
}
catch (cl::Error& error)
{
throw WrapClError(error, location);
}
}
} //namespace armnn
|
