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
|
/*
* Copyright (c) 2017-2019 ARM Limited.
*
* SPDX-License-Identifier: MIT
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to
* deal in the Software without restriction, including without limitation the
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#ifndef __ARM_COMPUTE_NEASYMM_H__
#define __ARM_COMPUTE_NEASYMM_H__
#include <arm_neon.h>
namespace arm_compute
{
using qasymm8x8_t = uint8x8_t; /**< 8 bit quantized asymmetric vector with 8 elements */
using qasymm8x8x2_t = uint8x8x2_t; /**< 8 bit quantized asymmetric vector with 16 elements */
using qasymm8x8x3_t = uint8x8x3_t; /**< 8 bit quantized asymmetric vector with 24 elements */
using qasymm8x8x4_t = uint8x8x4_t; /**< 8 bit quantized asymmetric vector with 32 elements */
using qasymm8x16_t = uint8x16_t; /**< 8 bit quantized asymmetric vector with 16 elements */
/** Round to the nearest division by a power-of-two using exponent
*
* @note This function calculates the following expression: (x + 2^n -1 ) / 2^n where n = exponent
*
* @param[in] x Vector of 4 elements
* @param[in] exponent Integer value used to round to nearest division by a power-of-two
*
* @return the nearest division by a power-of-two using exponent
*/
int32x4_t rounding_divide_by_pow2(int32x4_t x, int exponent);
/** Perform a multiply-accumulate on all 16 components of a QASYMM8 vector
*
* vd*vs + vo
*
* @param[in] vd Input vector value in QASYMM8 format
* @param[in] vs Vector multiplier in F32 format. The multiplier value must be duplicated across all four lanes.
* @param[in] vo Vector addend in F32 format. The addend value must be duplicated across all four lanes.
*
* @return A 16-component vector in QASYMM8 format, saturated to fit
*/
uint8x16_t vmlaq_qasymm8(qasymm8x16_t vd, float32x4_t vs, float32x4_t vo);
/** Performs final quantization step on 16 elements
*
* @tparam is_bounded_relu Specified if a fused bounded relu should be applied
*
* @param in_s32 Input to be quantized.
* @param result_fixedpoint_multiplier Result multiplier parameter
* @param result_shift Result shift parameter
* @param result_offset_after_shift_s32 Result offset parameter
* @param min_u8 Relu lower bound
* @param max_u8 Relu upper bound
*
* @return Quantized values
*/
template <bool is_bounded_relu>
uint8x16_t finalize_quantization(int32x4x4_t &in_s32,
int result_fixedpoint_multiplier,
int32_t result_shift,
int32x4_t result_offset_after_shift_s32,
uint8x16_t min_u8,
uint8x16_t max_u8)
{
const static int32x4_t zero_s32 = vdupq_n_s32(0);
// Fixed point multiplication with vector saturating rounding doubling multiply high with scalar
in_s32.val[0] = vqrdmulhq_n_s32(in_s32.val[0], result_fixedpoint_multiplier);
in_s32.val[1] = vqrdmulhq_n_s32(in_s32.val[1], result_fixedpoint_multiplier);
in_s32.val[2] = vqrdmulhq_n_s32(in_s32.val[2], result_fixedpoint_multiplier);
in_s32.val[3] = vqrdmulhq_n_s32(in_s32.val[3], result_fixedpoint_multiplier);
// Round to the nearest division by a power-of-two using result_shift_s32
in_s32.val[0] = rounding_divide_by_pow2(in_s32.val[0], result_shift);
in_s32.val[1] = rounding_divide_by_pow2(in_s32.val[1], result_shift);
in_s32.val[2] = rounding_divide_by_pow2(in_s32.val[2], result_shift);
in_s32.val[3] = rounding_divide_by_pow2(in_s32.val[3], result_shift);
// Add the offset terms
in_s32.val[0] = vaddq_s32(in_s32.val[0], result_offset_after_shift_s32);
in_s32.val[1] = vaddq_s32(in_s32.val[1], result_offset_after_shift_s32);
in_s32.val[2] = vaddq_s32(in_s32.val[2], result_offset_after_shift_s32);
in_s32.val[3] = vaddq_s32(in_s32.val[3], result_offset_after_shift_s32);
// Saturate negative values
in_s32.val[0] = vmaxq_s32(in_s32.val[0], zero_s32);
in_s32.val[1] = vmaxq_s32(in_s32.val[1], zero_s32);
in_s32.val[2] = vmaxq_s32(in_s32.val[2], zero_s32);
in_s32.val[3] = vmaxq_s32(in_s32.val[3], zero_s32);
// Convert S32 to S16
const int16x8x2_t in_s16 =
{
{
vcombine_s16(vqmovn_s32(in_s32.val[0]), vqmovn_s32(in_s32.val[1])),
vcombine_s16(vqmovn_s32(in_s32.val[2]), vqmovn_s32(in_s32.val[3]))
}
};
// Convert S16 to U8
uint8x16_t out_u8 = vcombine_u8(vqmovun_s16(in_s16.val[0]), vqmovun_s16(in_s16.val[1]));
if(is_bounded_relu)
{
out_u8 = vmaxq_u8(out_u8, min_u8);
out_u8 = vminq_u8(out_u8, max_u8);
}
return out_u8;
}
/** Dequantize a neon vector holding 16 quantized values.
*
* @param qv Input values to be dequantized.
* @param qi Quantization information to be used in the computation.
*
* @return Dequantized values in a neon vector
*/
inline float32x4x4_t vdequantize(const uint8x16_t &qv, const QuantizationInfo &qi)
{
const float scale = qi.scale;
const int offset = qi.offset;
const int32x4_t voffset = vdupq_n_s32(offset);
const float32x4_t vscale = vdupq_n_f32(scale);
const float32x4x4_t vdequantized_input =
{
{
vmulq_f32(vcvtq_f32_s32(vsubq_s32(vreinterpretq_s32_u32(vmovl_u16(vget_low_u16(vmovl_u8(vget_low_u8(qv))))), voffset)), vscale),
vmulq_f32(vcvtq_f32_s32(vsubq_s32(vreinterpretq_s32_u32(vmovl_u16(vget_high_u16(vmovl_u8(vget_low_u8(qv))))), voffset)), vscale),
vmulq_f32(vcvtq_f32_s32(vsubq_s32(vreinterpretq_s32_u32(vmovl_u16(vget_low_u16(vmovl_u8(vget_high_u8(qv))))), voffset)), vscale),
vmulq_f32(vcvtq_f32_s32(vsubq_s32(vreinterpretq_s32_u32(vmovl_u16(vget_high_u16(vmovl_u8(vget_high_u8(qv))))), voffset)), vscale),
}
};
return vdequantized_input;
}
/** Quantize a neon vector holding 16 floating point values.
*
* @param qv Input values to be quantized.
* @param qi Quantization information to be used in the computation.
*
* @return A neon vector holding the quantized values
*/
inline uint8x16_t vquantize(const float32x4x4_t &qv, const QuantizationInfo &qi)
{
const float scale = qi.scale;
const int offset = qi.offset;
const float32x4_t voffset = vdupq_n_f32(offset);
const float32x4_t vinvscale = vdupq_n_f32(1.f / scale);
const int32x4x4_t rf =
{
{
#ifdef __aarch64__
vcvtnq_s32_f32(vmlaq_f32(voffset, qv.val[0], vinvscale)),
vcvtnq_s32_f32(vmlaq_f32(voffset, qv.val[1], vinvscale)),
vcvtnq_s32_f32(vmlaq_f32(voffset, qv.val[2], vinvscale)),
vcvtnq_s32_f32(vmlaq_f32(voffset, qv.val[3], vinvscale)),
#else //__aarch64__
vcvtq_s32_f32(vmlaq_f32(voffset, qv.val[0], vinvscale)),
vcvtq_s32_f32(vmlaq_f32(voffset, qv.val[1], vinvscale)),
vcvtq_s32_f32(vmlaq_f32(voffset, qv.val[2], vinvscale)),
vcvtq_s32_f32(vmlaq_f32(voffset, qv.val[3], vinvscale)),
#endif //__aarch64__
}
};
const uint8x8_t pa = vqmovun_s16(vcombine_s16(vqmovn_s32(rf.val[0]), vqmovn_s32(rf.val[1])));
const uint8x8_t pb = vqmovun_s16(vcombine_s16(vqmovn_s32(rf.val[2]), vqmovn_s32(rf.val[3])));
return vcombine_u8(pa, pb);
}
} // namespace arm_compute
#include "arm_compute/core/NEON/NEAsymm.inl"
#endif // __ARM_COMPUTE_NEASYMM_H__
|
