experiments/STT-tensorflow
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

migrate MultiplyByQuantizedMultiplier4Rows to common.

Browse Source 
PiperOrigin-RevId: 343700272
Change-Id: I647df89a013a900ed25b0f8b9ebc21029cee00ad
This commit is contained in:
Renjie Liu 2020-11-21 22:09:59 -08:00 committed by TensorFlower Gardener
parent 063940bae3
commit 4827424ac3
5 changed files with 65 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
tensorflow/lite/kernels/internal/common.h
View File

@ -186,6 +186,42 @@ inline int32_t MultiplyByQuantizedMultiplier(int64_t x,
return result;
}
#ifdef USE_NEON
// Round uses ARM's rounding shift right.
inline int32x4x4_t MultiplyByQuantizedMultiplier4Rows(
int32x4x4_t input_val, int32 quantized_multiplier, int shift) {
const int left_shift = std::max(shift, 0);
const int right_shift = std::min(shift, 0);
int32x4x4_t result;
int32x4_t multiplier_dup = vdupq_n_s32(quantized_multiplier);
int32x4_t left_shift_dup = vdupq_n_s32(left_shift);
int32x4_t right_shift_dup = vdupq_n_s32(right_shift);
result.val[0] =
vrshlq_s32(vqrdmulhq_s32(vshlq_s32(input_val.val[0], left_shift_dup),
multiplier_dup),
right_shift_dup);
result.val[1] =
vrshlq_s32(vqrdmulhq_s32(vshlq_s32(input_val.val[1], left_shift_dup),
multiplier_dup),
right_shift_dup);
result.val[2] =
vrshlq_s32(vqrdmulhq_s32(vshlq_s32(input_val.val[2], left_shift_dup),
multiplier_dup),
right_shift_dup);
result.val[3] =
vrshlq_s32(vqrdmulhq_s32(vshlq_s32(input_val.val[3], left_shift_dup),
multiplier_dup),
right_shift_dup);
return result;
}
#endif
template <typename T>
int CountLeadingZeros(T integer_input) {
static_assert(std::is_unsigned<T>::value,

4
tensorflow/lite/kernels/internal/optimized/integer_ops/mean.h
View File

@ -89,8 +89,8 @@ inline void MeanImpl(const tflite::MeanParams& op_params,
}
}
temp_sum = optimized_ops::MultiplyByQuantizedMultiplier4Rows(
temp_sum, multiplier, shift);
temp_sum =
MultiplyByQuantizedMultiplier4Rows(temp_sum, multiplier, shift);
temp_sum.val[0] = vaddq_s32(temp_sum.val[0], bias_dup);
temp_sum.val[1] = vaddq_s32(temp_sum.val[1], bias_dup);

63
tensorflow/lite/kernels/internal/optimized/neon_tensor_utils.cc
View File

@ -127,69 +127,6 @@ inline int32_t AccumulateNeonLane(const int32x4_t lane) {
#endif
}
// TODO(jaesung): Merge duplicated implementations in optimized_ops.h and
// neon_tensor_utils.cc.
inline int32x4x4_t MultiplyByQuantizedMultiplier4Rows(
int32x4x4_t input_val, int32 quantized_multiplier, int shift) {
using gemmlowp::RoundingDivideByPOT;
using gemmlowp::SaturatingRoundingDoublingHighMul;
const int left_shift = shift > 0 ? shift : 0;
const int right_shift = shift > 0 ? 0 : -shift;
int32x4x4_t result;
// The vector type support for SaturatingRoundingDoublingHighMulth in gemmlowp
// is limited to NEON.
#ifdef GEMMLOWP_NEON
const int32x4_t left_shifted_one_dup = vdupq_n_s32(1 << left_shift);
result.val[0] =
RoundingDivideByPOT(SaturatingRoundingDoublingHighMul(
vmulq_s32(input_val.val[0], left_shifted_one_dup),
quantized_multiplier),
right_shift);
result.val[1] =
RoundingDivideByPOT(SaturatingRoundingDoublingHighMul(
vmulq_s32(input_val.val[1], left_shifted_one_dup),
quantized_multiplier),
right_shift);
result.val[2] =
RoundingDivideByPOT(SaturatingRoundingDoublingHighMul(
vmulq_s32(input_val.val[2], left_shifted_one_dup),
quantized_multiplier),
right_shift);
result.val[3] =
RoundingDivideByPOT(SaturatingRoundingDoublingHighMul(
vmulq_s32(input_val.val[3], left_shifted_one_dup),
quantized_multiplier),
right_shift);
#else
for (int i = 0; i < 4; ++i) {
int32_t vals[4];
vals[0] = RoundingDivideByPOT(
SaturatingRoundingDoublingHighMul(
vgetq_lane_s32(input_val.val[i], 0) * (1 << left_shift),
quantized_multiplier),
right_shift);
vals[1] = RoundingDivideByPOT(
SaturatingRoundingDoublingHighMul(
vgetq_lane_s32(input_val.val[i], 1) * (1 << left_shift),
quantized_multiplier),
right_shift);
vals[2] = RoundingDivideByPOT(
SaturatingRoundingDoublingHighMul(
vgetq_lane_s32(input_val.val[i], 2) * (1 << left_shift),
quantized_multiplier),
right_shift);
vals[3] = RoundingDivideByPOT(
SaturatingRoundingDoublingHighMul(
vgetq_lane_s32(input_val.val[i], 3) * (1 << left_shift),
quantized_multiplier),
right_shift);
result.val[i] = vld1q_s32(reinterpret_cast<int32_t*>(&vals));
}
#endif
return result;
}
inline int32x4x2_t MultiplyByQuantizedMultiplier2Rows(
int32x4x2_t input_val, int32 quantized_multiplier, int shift) {
using gemmlowp::RoundingDivideByPOT;

37
tensorflow/lite/kernels/internal/optimized/optimized_ops.h
View File

@ -201,43 +201,6 @@ MatrixMap<Scalar> MapAsMatrixWithGivenNumberOfRows(Scalar* data,
return MatrixMap<Scalar>(data, rows, cols);
}
// TODO(b/173708994): Refactor this to merge with other
// MultiplyByQuantizedMultipler.
#ifdef USE_NEON
inline int32x4x4_t MultiplyByQuantizedMultiplier4Rows(
int32x4x4_t input_val, int32 quantized_multiplier, int32 shift) {
const int left_shift = std::max(shift, 0);
const int right_shift = std::min(shift, 0);
int32x4x4_t result;
int32x4_t multiplier_dup = vdupq_n_s32(quantized_multiplier);
int32x4_t left_shift_dup = vdupq_n_s32(left_shift);
int32x4_t right_shift_dup = vdupq_n_s32(right_shift);
result.val[0] =
vrshlq_s32(vqrdmulhq_s32(vshlq_s32(input_val.val[0], left_shift_dup),
multiplier_dup),
right_shift_dup);
result.val[1] =
vrshlq_s32(vqrdmulhq_s32(vshlq_s32(input_val.val[1], left_shift_dup),
multiplier_dup),
right_shift_dup);
result.val[2] =
vrshlq_s32(vqrdmulhq_s32(vshlq_s32(input_val.val[2], left_shift_dup),
multiplier_dup),
right_shift_dup);
result.val[3] =
vrshlq_s32(vqrdmulhq_s32(vshlq_s32(input_val.val[3], left_shift_dup),
multiplier_dup),
right_shift_dup);
return result;
}
#endif
template <typename ElementwiseF, typename ScalarBroadcastF, typename T>
inline void BinaryBroadcastFiveFold(const ArithmeticParams& unswitched_params,
const RuntimeShape& unswitched_input1_shape,

29
tensorflow/lite/kernels/internal/tensor_utils_test.cc
View File

@ -30,6 +30,29 @@ limitations under the License.
namespace tflite {
namespace tensor_utils {
// Normally we should require bit-for-bit exact results. Unfortunately a bug
// in the Intel arm_neon_sse.h translation header that we use for x86 tests
// causes 1-bit inaccuracy in the vqrdmulh_n_s32 intrinsic, which causes
// off-by-1 errors. So we have to live with a
// few off-by-one errors for now, yet still ensure that no more than a small
// minority of values are wrong.
// This util is to compare the rounding results for integer-output.
template <typename T>
void CompareRoundingResults(int flat_size, const T* expected_result,
const T* real_result, int max_element_tolerance = 1,
int max_total_tolerance = 5) {
int max_diff = 0;
int64_t total_diff = 0;
for (int i = 0; i < flat_size; i++) {
int diff = static_cast<int>(std::abs(expected_result[i] - real_result[i]));
total_diff += diff;
max_diff = std::max(max_diff, diff);
}
EXPECT_LE(max_diff, max_element_tolerance);
EXPECT_LE(total_diff, max_total_tolerance);
}
TEST(uKernels, FloorLog2Test) {
for (int i = 1; i < 257; ++i) {
EXPECT_EQ(::tflite::FloorLog2(i),
@ -1758,7 +1781,7 @@ TEST(uKernels, VectorBatchVectorCwiseProductAccumulateInteger) {
const std::vector<int16_t> expected_output = {
/* batch 0 */
-35, 34, 32, 30, 27, 24, 20, 16, 11, -2, 10, 13, 16, 18, 19, 20, 21, 21,
-35, 34, 32, 30, 27, 24, 20, 16, 11, -1, 10, 13, 16, 18, 19, 20, 21, 21,
20, 0, 4, 8, 12, 17, 23, 29, 35, 42, 50,
/* batch 1 */
27, 24, 20, 18, 15, 14, 12, 12, 1, 2, 2, 6, 10, 15, 20, 26, 32, 39, 26, 9,
@ -1769,7 +1792,9 @@ TEST(uKernels, VectorBatchVectorCwiseProductAccumulateInteger) {
/* batch 3 */
17, 21, 14, 17, 18, 20, 20, 21, 20, 20, 18, -7, 13, 14, 13, 13, 11, 10, 7,
5, 26, 31, 37, 56, 63, 72, 80, 90, 99};
EXPECT_THAT(batch_output, testing::ElementsAreArray(expected_output));
// Only allow 1 element difference for the rounding result.
CompareRoundingResults<int16_t>(4 * 29, expected_output.data(),
batch_output.data(), 1, 1);
}
TEST(uKernels, VectorBatchVectorCwiseProductAccumulateFloat) {