status-im
/
leopard
mirror of https://github.com/status-im/leopard.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

FF16 works

This commit is contained in:
Christopher Taylor 2017-05-30 02:05:41 -07:00
parent d0a3aa287d
commit c53b075eda
4 changed files with 16 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
LeopardCommon.h
View File

@ -149,9 +149,6 @@
//------------------------------------------------------------------------------
// Constants
// Unroll inner loops 4 times
//#define LEO_USE_VECTOR4_OPT
// Define this to enable the optimized version of FWHT()
#define LEO_FWHT_OPT
@ -164,6 +161,9 @@
// Optimize M=1 case
#define LEO_M1_OPT
// Unroll inner loops 4 times
#define LEO_USE_VECTOR4_OPT
//------------------------------------------------------------------------------
// Debug

33
LeopardFF16.cpp
View File

@ -636,8 +636,7 @@ void fft_butterfly4(
#if defined(LEO_TRY_AVX2)
if (CpuHasAVX2)
{
const LEO_M256 table_lo_y = _mm256_loadu_si256(&Multiply256LUT[log_m].Value[0]);
const LEO_M256 table_hi_y = _mm256_loadu_si256(&Multiply256LUT[log_m].Value[1]);
LEO_MUL_TABLES_256();
const LEO_M256 clr_mask = _mm256_set1_epi8(0x0f);
@ -652,19 +651,15 @@ void fft_butterfly4(
do
{
LEO_FFTB_256(x32_0 + 1, y32_0 + 1);
LEO_FFTB_256(x32_0, y32_0);
y32_0 += 2, x32_0 += 2;
LEO_FFTB_256(x32_1 + 1, y32_1 + 1);
LEO_FFTB_256(x32_1, y32_1);
y32_1 += 2, x32_1 += 2;
LEO_FFTB_256(x32_2 + 1, y32_2 + 1);
LEO_FFTB_256(x32_2, y32_2);
y32_2 += 2, x32_2 += 2;
LEO_FFTB_256(x32_3 + 1, y32_3 + 1);
LEO_FFTB_256(x32_3, y32_3);
y32_3 += 2, x32_3 += 2;
@ -690,26 +685,18 @@ void fft_butterfly4(
do
{
LEO_FFTB_128(x16_0 + 3, y16_0 + 3);
LEO_FFTB_128(x16_0 + 2, y16_0 + 2);
LEO_FFTB_128(x16_0 + 1, y16_0 + 1);
LEO_FFTB_128(x16_0, y16_0);
x16_0 += 4, y16_0 += 4;
LEO_FFTB_128(x16_1 + 3, y16_1 + 3);
LEO_FFTB_128(x16_1 + 2, y16_1 + 2);
LEO_FFTB_128(x16_1 + 1, y16_1 + 1);
LEO_FFTB_128(x16_1, y16_1);
x16_1 += 4, y16_1 += 4;
LEO_FFTB_128(x16_2 + 3, y16_2 + 3);
LEO_FFTB_128(x16_2 + 2, y16_2 + 2);
LEO_FFTB_128(x16_2 + 1, y16_2 + 1);
LEO_FFTB_128(x16_2, y16_2);
x16_2 += 4, y16_2 += 4;
LEO_FFTB_128(x16_3 + 3, y16_3 + 3);
LEO_FFTB_128(x16_3 + 2, y16_3 + 2);
LEO_FFTB_128(x16_3 + 1, y16_3 + 1);
LEO_FFTB_128(x16_3, y16_3);
x16_3 += 4, y16_3 += 4;
@ -835,8 +822,7 @@ void ifft_butterfly4(
#if defined(LEO_TRY_AVX2)
if (CpuHasAVX2)
{
const LEO_M256 table_lo_y = _mm256_loadu_si256(&Multiply256LUT[log_m].Value[0]);
const LEO_M256 table_hi_y = _mm256_loadu_si256(&Multiply256LUT[log_m].Value[1]);
LEO_MUL_TABLES_256();
const LEO_M256 clr_mask = _mm256_set1_epi8(0x0f);
@ -851,19 +837,15 @@ void ifft_butterfly4(
do
{
LEO_IFFTB_256(x32_0 + 1, y32_0 + 1);
LEO_IFFTB_256(x32_0, y32_0);
y32_0 += 2, x32_0 += 2;
LEO_IFFTB_256(x32_1 + 1, y32_1 + 1);
LEO_IFFTB_256(x32_1, y32_1);
y32_1 += 2, x32_1 += 2;
LEO_IFFTB_256(x32_2 + 1, y32_2 + 1);
LEO_IFFTB_256(x32_2, y32_2);
y32_2 += 2, x32_2 += 2;
LEO_IFFTB_256(x32_3 + 1, y32_3 + 1);
LEO_IFFTB_256(x32_3, y32_3);
y32_3 += 2, x32_3 += 2;
@ -874,8 +856,7 @@ void ifft_butterfly4(
}
#endif // LEO_TRY_AVX2
const LEO_M128 table_lo_y = _mm_loadu_si128(&Multiply128LUT[log_m].Value[0]);
const LEO_M128 table_hi_y = _mm_loadu_si128(&Multiply128LUT[log_m].Value[1]);
LEO_MUL_TABLES_128();
const LEO_M128 clr_mask = _mm_set1_epi8(0x0f);
@ -890,26 +871,18 @@ void ifft_butterfly4(
do
{
LEO_IFFTB_128(x16_0 + 3, y16_0 + 3);
LEO_IFFTB_128(x16_0 + 2, y16_0 + 2);
LEO_IFFTB_128(x16_0 + 1, y16_0 + 1);
LEO_IFFTB_128(x16_0, y16_0);
x16_0 += 4, y16_0 += 4;
LEO_IFFTB_128(x16_1 + 3, y16_1 + 3);
LEO_IFFTB_128(x16_1 + 2, y16_1 + 2);
LEO_IFFTB_128(x16_1 + 1, y16_1 + 1);
LEO_IFFTB_128(x16_1, y16_1);
x16_1 += 4, y16_1 += 4;
LEO_IFFTB_128(x16_2 + 3, y16_2 + 3);
LEO_IFFTB_128(x16_2 + 2, y16_2 + 2);
LEO_IFFTB_128(x16_2 + 1, y16_2 + 1);
LEO_IFFTB_128(x16_2, y16_2);
x16_2 += 4, y16_2 += 4;
LEO_IFFTB_128(x16_3 + 3, y16_3 + 3);
LEO_IFFTB_128(x16_3 + 2, y16_3 + 2);
LEO_IFFTB_128(x16_3 + 1, y16_3 + 1);
LEO_IFFTB_128(x16_3, y16_3);
x16_3 += 4, y16_3 += 4;

4
leopard.h
View File

@ -64,13 +64,15 @@
/*
TODO:
+ Benchmarks for large data!
+ Add multi-threading to split up long parallelizable calculations
+ Final benchmarks!
+ Release version 1
+ Finish up documentation
TBD:
+ Look into 12-bit fields as a performance optimization
+ Look into shortening the FWHT() since it takes a lot of decoder runtime
+ Unroll first/final butterflies to avoid extra copies/xors in encoder
+ Look into getting EncodeL working so we can support smaller data (Ask Lin)
+ Look into using FFT_m instead of FFT_n for decoder
*/

11
tests/benchmark.cpp
View File

@ -42,14 +42,14 @@ using namespace std;
struct TestParameters
{
#ifdef LEO_HAS_FF16
unsigned original_count = 677; // under 65536
unsigned recovery_count = 487; // under 65536 - original_count
unsigned original_count = 1000; // under 65536
unsigned recovery_count = 200; // under 65536 - original_count
#else
unsigned original_count = 128; // under 65536
unsigned recovery_count = 128; // under 65536 - original_count
#endif
unsigned buffer_bytes = 2560; // multiple of 64 bytes
unsigned loss_count = 2; // some fraction of original_count
unsigned loss_count = 500; // some fraction of original_count
unsigned seed = 2;
bool multithreaded = true;
};
@ -807,10 +807,13 @@ int main(int argc, char **argv)
if (!BasicTest(params))
goto Failed;
static const unsigned kMaxRandomData = 32768;
prng.Seed(params.seed, 8);
for (;; ++params.seed)
{
params.original_count = prng.Next() % 32768;
params.original_count = prng.Next() % kMaxRandomData;
params.recovery_count = prng.Next() % params.original_count + 1;
params.loss_count = prng.Next() % params.recovery_count + 1;