Add fixed_compute_best_predictor_wide_intrin_avx2
This function executes twice as fast as plain C, test with Intel Xeon E-2224G
This commit is contained in:
Martijn van Beurden
parent
3173fc064f
commit
f6fb70442e
@ -19,7 +19,7 @@ if(FLAC__CPU_X86_64 OR FLAC__CPU_IA32)
|
||||
set(FLAC__ALIGN_MALLOC_DATA 1)
|
||||
option(WITH_AVX "Enable AVX, AVX2 optimizations (with runtime detection, resulting binary does not require AVX2, so only necessary when a compiler doesn't know about AVX)" ON)
|
||||
if(WITH_AVX AND MSVC)
|
||||
set_source_files_properties(lpc_intrin_avx2.c stream_encoder_intrin_avx2.c lpc_intrin_fma.c PROPERTIES COMPILE_FLAGS /arch:AVX2)
|
||||
set_source_files_properties(fixed_intrin_avx2.c lpc_intrin_avx2.c stream_encoder_intrin_avx2.c lpc_intrin_fma.c PROPERTIES COMPILE_FLAGS /arch:AVX2)
|
||||
endif()
|
||||
else()
|
||||
check_cpu_arch_arm64(FLAC__CPU_ARM64)
|
||||
@ -43,6 +43,7 @@ add_library(FLAC
|
||||
fixed.c
|
||||
fixed_intrin_sse2.c
|
||||
fixed_intrin_ssse3.c
|
||||
fixed_intrin_avx2.c
|
||||
float.c
|
||||
format.c
|
||||
lpc.c
|
||||
|
||||
@ -84,6 +84,7 @@ libFLAC_sources = \
|
||||
fixed.c \
|
||||
fixed_intrin_sse2.c \
|
||||
fixed_intrin_ssse3.c \
|
||||
fixed_intrin_avx2.c \
|
||||
float.c \
|
||||
format.c \
|
||||
lpc.c \
|
||||
|
||||
173
src/libFLAC/fixed_intrin_avx2.c
Normal file
173
src/libFLAC/fixed_intrin_avx2.c
Normal file
@ -0,0 +1,173 @@
|
||||
/* libFLAC - Free Lossless Audio Codec library
|
||||
* Copyright (C) 2000-2009 Josh Coalson
|
||||
* Copyright (C) 2011-2022 Xiph.Org Foundation
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* - Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* - Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* - Neither the name of the Xiph.org Foundation nor the names of its
|
||||
* contributors may be used to endorse or promote products derived from
|
||||
* this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR
|
||||
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
||||
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
||||
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
||||
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include <config.h>
|
||||
#endif
|
||||
|
||||
#include "private/cpu.h"
|
||||
|
||||
#ifndef FLAC__INTEGER_ONLY_LIBRARY
|
||||
#ifndef FLAC__NO_ASM
|
||||
#if (defined FLAC__CPU_IA32 || defined FLAC__CPU_X86_64) && FLAC__HAS_X86INTRIN
|
||||
#include "private/fixed.h"
|
||||
#ifdef FLAC__AVX2_SUPPORTED
|
||||
|
||||
#include <immintrin.h>
|
||||
#include <math.h>
|
||||
#include "private/macros.h"
|
||||
#include "share/compat.h"
|
||||
#include "FLAC/assert.h"
|
||||
|
||||
#ifdef local_abs
|
||||
#undef local_abs
|
||||
#endif
|
||||
#define local_abs(x) ((uint32_t)((x)<0? -(x) : (x)))
|
||||
|
||||
FLAC__SSE_TARGET("avx2")
|
||||
uint32_t FLAC__fixed_compute_best_predictor_wide_intrin_avx2(const FLAC__int32 data[], uint32_t data_len, float residual_bits_per_sample[FLAC__MAX_FIXED_ORDER + 1])
|
||||
{
|
||||
FLAC__uint64 total_error_0, total_error_1, total_error_2, total_error_3, total_error_4;
|
||||
FLAC__int32 i, data_len_int;
|
||||
uint32_t order;
|
||||
__m256i total_err0, total_err1, total_err2, total_err3, total_err4;
|
||||
__m256i prev_err0, prev_err1, prev_err2, prev_err3;
|
||||
__m256i tempA, tempB, bitmask;
|
||||
FLAC__int64 data_scalar[4];
|
||||
FLAC__int64 prev_err0_scalar[4];
|
||||
FLAC__int64 prev_err1_scalar[4];
|
||||
FLAC__int64 prev_err2_scalar[4];
|
||||
FLAC__int64 prev_err3_scalar[4];
|
||||
total_err0 = _mm256_setzero_si256();
|
||||
total_err1 = _mm256_setzero_si256();
|
||||
total_err2 = _mm256_setzero_si256();
|
||||
total_err3 = _mm256_setzero_si256();
|
||||
total_err4 = _mm256_setzero_si256();
|
||||
data_len_int = data_len;
|
||||
|
||||
for(i = 0; i < 4; i++){
|
||||
prev_err0_scalar[i] = data[-1+i*(data_len_int/4)];
|
||||
prev_err1_scalar[i] = data[-1+i*(data_len_int/4)] - data[-2+i*(data_len_int/4)];
|
||||
prev_err2_scalar[i] = prev_err1_scalar[i] - (data[-2+i*(data_len_int/4)] - data[-3+i*(data_len_int/4)]);
|
||||
prev_err3_scalar[i] = prev_err2_scalar[i] - (data[-2+i*(data_len_int/4)] - 2*data[-3+i*(data_len_int/4)] + data[-4+i*(data_len_int/4)]);
|
||||
}
|
||||
prev_err0 = _mm256_loadu_si256((const __m256i*)prev_err0_scalar);
|
||||
prev_err1 = _mm256_loadu_si256((const __m256i*)prev_err1_scalar);
|
||||
prev_err2 = _mm256_loadu_si256((const __m256i*)prev_err2_scalar);
|
||||
prev_err3 = _mm256_loadu_si256((const __m256i*)prev_err3_scalar);
|
||||
for(i = 0; i < data_len_int / 4; i++){
|
||||
data_scalar[0] = data[i];
|
||||
data_scalar[1] = data[i+data_len/4];
|
||||
data_scalar[2] = data[i+2*data_len/4];
|
||||
data_scalar[3] = data[i+3*data_len/4];
|
||||
tempA = _mm256_loadu_si256((const __m256i*)data_scalar);
|
||||
/* Next three intrinsics calculate tempB as abs of tempA */
|
||||
bitmask = _mm256_cmpgt_epi64(_mm256_set1_epi64x(0), tempA);
|
||||
tempB = _mm256_xor_si256(tempA, bitmask);
|
||||
tempB = _mm256_sub_epi64(tempB, bitmask);
|
||||
total_err0 = _mm256_add_epi64(total_err0,tempB);
|
||||
tempB = _mm256_sub_epi64(tempA,prev_err0);
|
||||
prev_err0 = tempA;
|
||||
/* Next three intrinsics calculate tempA as abs of tempB */
|
||||
bitmask = _mm256_cmpgt_epi64(_mm256_set1_epi64x(0), tempB);
|
||||
tempA = _mm256_xor_si256(tempB, bitmask);
|
||||
tempA = _mm256_sub_epi64(tempA, bitmask);
|
||||
total_err1 = _mm256_add_epi64(total_err1,tempA);
|
||||
tempA = _mm256_sub_epi64(tempB,prev_err1);
|
||||
prev_err1 = tempB;
|
||||
/* Next three intrinsics calculate tempB as abs of tempA */
|
||||
bitmask = _mm256_cmpgt_epi64(_mm256_set1_epi64x(0), tempA);
|
||||
tempB = _mm256_xor_si256(tempA, bitmask);
|
||||
tempB = _mm256_sub_epi64(tempB, bitmask);
|
||||
total_err2 = _mm256_add_epi64(total_err2,tempB);
|
||||
tempB = _mm256_sub_epi64(tempA,prev_err2);
|
||||
prev_err2 = tempA;
|
||||
/* Next three intrinsics calculate tempA as abs of tempB */
|
||||
bitmask = _mm256_cmpgt_epi64(_mm256_set1_epi64x(0), tempB);
|
||||
tempA = _mm256_xor_si256(tempB, bitmask);
|
||||
tempA = _mm256_sub_epi64(tempA, bitmask);
|
||||
total_err3 = _mm256_add_epi64(total_err3,tempA);
|
||||
tempA = _mm256_sub_epi64(tempB,prev_err3);
|
||||
prev_err3 = tempB;
|
||||
/* Next three intrinsics calculate tempB as abs of tempA */
|
||||
bitmask = _mm256_cmpgt_epi64(_mm256_set1_epi64x(0), tempA);
|
||||
tempB = _mm256_xor_si256(tempA, bitmask);
|
||||
tempB = _mm256_sub_epi64(tempB, bitmask);
|
||||
total_err4 = _mm256_add_epi64(total_err4,tempB);
|
||||
}
|
||||
_mm256_storeu_si256((__m256i*)data_scalar,total_err0);
|
||||
total_error_0 = data_scalar[0] + data_scalar[1] + data_scalar[2] + data_scalar[3];
|
||||
_mm256_storeu_si256((__m256i*)data_scalar,total_err1);
|
||||
total_error_1 = data_scalar[0] + data_scalar[1] + data_scalar[2] + data_scalar[3];
|
||||
_mm256_storeu_si256((__m256i*)data_scalar,total_err2);
|
||||
total_error_2 = data_scalar[0] + data_scalar[1] + data_scalar[2] + data_scalar[3];
|
||||
_mm256_storeu_si256((__m256i*)data_scalar,total_err3);
|
||||
total_error_3 = data_scalar[0] + data_scalar[1] + data_scalar[2] + data_scalar[3];
|
||||
_mm256_storeu_si256((__m256i*)data_scalar,total_err4);
|
||||
total_error_4 = data_scalar[0] + data_scalar[1] + data_scalar[2] + data_scalar[3];
|
||||
|
||||
/* Ignore the remainder, we're ignore the first few samples too */
|
||||
|
||||
/* prefer lower order */
|
||||
if(total_error_0 <= flac_min(flac_min(flac_min(total_error_1, total_error_2), total_error_3), total_error_4))
|
||||
order = 0;
|
||||
else if(total_error_1 <= flac_min(flac_min(total_error_2, total_error_3), total_error_4))
|
||||
order = 1;
|
||||
else if(total_error_2 <= flac_min(total_error_3, total_error_4))
|
||||
order = 2;
|
||||
else if(total_error_3 <= total_error_4)
|
||||
order = 3;
|
||||
else
|
||||
order = 4;
|
||||
|
||||
/* Estimate the expected number of bits per residual signal sample. */
|
||||
/* 'total_error*' is linearly related to the variance of the residual */
|
||||
/* signal, so we use it directly to compute E(|x|) */
|
||||
FLAC__ASSERT(data_len > 0 || total_error_0 == 0);
|
||||
FLAC__ASSERT(data_len > 0 || total_error_1 == 0);
|
||||
FLAC__ASSERT(data_len > 0 || total_error_2 == 0);
|
||||
FLAC__ASSERT(data_len > 0 || total_error_3 == 0);
|
||||
FLAC__ASSERT(data_len > 0 || total_error_4 == 0);
|
||||
|
||||
residual_bits_per_sample[0] = (float)((total_error_0 > 0) ? log(M_LN2 * (double)total_error_0 / (double)data_len) / M_LN2 : 0.0);
|
||||
residual_bits_per_sample[1] = (float)((total_error_1 > 0) ? log(M_LN2 * (double)total_error_1 / (double)data_len) / M_LN2 : 0.0);
|
||||
residual_bits_per_sample[2] = (float)((total_error_2 > 0) ? log(M_LN2 * (double)total_error_2 / (double)data_len) / M_LN2 : 0.0);
|
||||
residual_bits_per_sample[3] = (float)((total_error_3 > 0) ? log(M_LN2 * (double)total_error_3 / (double)data_len) / M_LN2 : 0.0);
|
||||
residual_bits_per_sample[4] = (float)((total_error_4 > 0) ? log(M_LN2 * (double)total_error_4 / (double)data_len) / M_LN2 : 0.0);
|
||||
|
||||
return order;
|
||||
}
|
||||
|
||||
#endif /* FLAC__AVX2_SUPPORTED */
|
||||
#endif /* (FLAC__CPU_IA32 || FLAC__CPU_X86_64) && FLAC__HAS_X86INTRIN */
|
||||
#endif /* FLAC__NO_ASM */
|
||||
#endif /* FLAC__INTEGER_ONLY_LIBRARY */
|
||||
@ -66,6 +66,9 @@ uint32_t FLAC__fixed_compute_best_predictor_intrin_sse2(const FLAC__int32 data[]
|
||||
# ifdef FLAC__SSSE3_SUPPORTED
|
||||
uint32_t FLAC__fixed_compute_best_predictor_intrin_ssse3(const FLAC__int32 data[], uint32_t data_len, float residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]);
|
||||
# endif
|
||||
# ifdef FLAC__AVX2_SUPPORTED
|
||||
uint32_t FLAC__fixed_compute_best_predictor_wide_intrin_avx2(const FLAC__int32 data[], uint32_t data_len, float residual_bits_per_sample[FLAC__MAX_FIXED_ORDER+1]);
|
||||
# endif
|
||||
# endif
|
||||
# endif
|
||||
#else
|
||||
|
||||
@ -994,6 +994,11 @@ static FLAC__StreamEncoderInitStatus init_stream_internal_(
|
||||
encoder->private_->local_fixed_compute_best_predictor = FLAC__fixed_compute_best_predictor_intrin_ssse3;
|
||||
}
|
||||
# endif
|
||||
# ifdef FLAC__AVX2_SUPPORTED
|
||||
if (encoder->private_->cpuinfo.x86.avx2) {
|
||||
encoder->private_->local_fixed_compute_best_predictor_wide = FLAC__fixed_compute_best_predictor_wide_intrin_avx2;
|
||||
}
|
||||
# endif
|
||||
# endif /* FLAC__HAS_X86INTRIN */
|
||||
# elif defined FLAC__CPU_X86_64
|
||||
FLAC__ASSERT(encoder->private_->cpuinfo.type == FLAC__CPUINFO_TYPE_X86_64);
|
||||
@ -1044,6 +1049,11 @@ static FLAC__StreamEncoderInitStatus init_stream_internal_(
|
||||
encoder->private_->local_fixed_compute_best_predictor = FLAC__fixed_compute_best_predictor_intrin_ssse3;
|
||||
}
|
||||
# endif
|
||||
# ifdef FLAC__AVX2_SUPPORTED
|
||||
if (encoder->private_->cpuinfo.x86.avx2) {
|
||||
encoder->private_->local_fixed_compute_best_predictor_wide = FLAC__fixed_compute_best_predictor_wide_intrin_avx2;
|
||||
}
|
||||
# endif
|
||||
# endif /* FLAC__HAS_X86INTRIN */
|
||||
# endif /* FLAC__CPU_... */
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user