mirror of https://github.com/PentHertz/srsLTE.git
750 lines
20 KiB
C
750 lines
20 KiB
C
|
/**
|
||
|
|
*
|
||
|
|
* \section COPYRIGHT
|
||
|
|
*
|
||
|
|
* Copyright 2013-2015 Software Radio Systems Limited
|
||
|
|
*
|
||
|
|
* \section LICENSE
|
||
|
|
*
|
||
|
|
* This file is part of the srsLTE library.
|
||
|
|
*
|
||
|
|
* srsLTE is free software: you can redistribute it and/or modify
|
||
|
|
* it under the terms of the GNU Affero General Public License as
|
||
|
|
* published by the Free Software Foundation, either version 3 of
|
||
|
|
* the License, or (at your option) any later version.
|
||
|
|
*
|
||
|
|
* srsLTE is distributed in the hope that it will be useful,
|
||
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
|
|
* GNU Affero General Public License for more details.
|
||
|
|
*
|
||
|
|
* A copy of the GNU Affero General Public License can be found in
|
||
|
|
* the LICENSE file in the top-level directory of this distribution
|
||
|
|
* and at http://www.gnu.org/licenses/.
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include "srslte/config.h"
|
||
|
|
|
||
|
|
#define MAKE_FUNC(a) CONCAT2(CONCAT2(tdec_win,WINIMP),CONCAT2(_,a))
|
||
|
|
#define MAKE_TYPE CONCAT2(CONCAT2(tdec_win_,WINIMP),_t)
|
||
|
|
|
||
|
|
#ifdef WINIMP_IS_SSE16
|
||
|
|
|
||
|
|
#ifndef LV_HAVE_SSE
|
||
|
|
#error "Selected SSE window decoder but instruction set not supported"
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#include <nmmintrin.h>
|
||
|
|
|
||
|
|
#define WINIMP sse16
|
||
|
|
#define nof_blocks 8
|
||
|
|
|
||
|
|
#define llr_t int16_t
|
||
|
|
|
||
|
|
#define simd_type_t __m128i
|
||
|
|
#define simd_load _mm_load_si128
|
||
|
|
#define simd_store _mm_store_si128
|
||
|
|
#define simd_add _mm_adds_epi16
|
||
|
|
#define simd_sub _mm_subs_epi16
|
||
|
|
#define simd_max _mm_max_epi16
|
||
|
|
#define simd_set1 _mm_set1_epi16
|
||
|
|
#define simd_insert _mm_insert_epi16
|
||
|
|
#define simd_shuffle _mm_shuffle_epi8
|
||
|
|
#define move_right _mm_set_epi8(15,14,15,14,13,12,11,10,9,8,7,6,5,4,3,2)
|
||
|
|
#define move_left _mm_set_epi8(13,12,11,10,9,8,7,6,5,4,3,2,1,0,1,0)
|
||
|
|
#define simd_rb_shift _mm_srai_epi16
|
||
|
|
|
||
|
|
#define normalize_period 2
|
||
|
|
#define win_overlap_len 40
|
||
|
|
|
||
|
|
#define divide_output 1
|
||
|
|
|
||
|
|
#define INF 10000
|
||
|
|
|
||
|
|
#else
|
||
|
|
#ifdef WINIMP_IS_AVX16
|
||
|
|
|
||
|
|
#ifndef LV_HAVE_AVX
|
||
|
|
#error "Selected AVX window decoder but instruction set not supported"
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#include <immintrin.h>
|
||
|
|
|
||
|
|
#define WINIMP avx16
|
||
|
|
#define nof_blocks 16
|
||
|
|
|
||
|
|
#define llr_t int16_t
|
||
|
|
|
||
|
|
#define simd_type_t __m256i
|
||
|
|
#define simd_load _mm256_load_si256
|
||
|
|
#define simd_store _mm256_store_si256
|
||
|
|
#define simd_add _mm256_adds_epi16
|
||
|
|
#define simd_sub _mm256_subs_epi16
|
||
|
|
#define simd_max _mm256_max_epi16
|
||
|
|
#define simd_set1 _mm256_set1_epi16
|
||
|
|
#define simd_insert _mm256_insert_epi16
|
||
|
|
#define simd_shuffle _mm256_shuffle_epi8
|
||
|
|
#define move_right _mm256_set_epi8(31,30,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2)
|
||
|
|
#define move_left _mm256_set_epi8(29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0,1,0)
|
||
|
|
|
||
|
|
#define normalize_period 2
|
||
|
|
#define win_overlap_len 40
|
||
|
|
|
||
|
|
#define INF 10000
|
||
|
|
#else
|
||
|
|
|
||
|
|
#ifdef WINIMP_IS_SSE8
|
||
|
|
|
||
|
|
#ifndef LV_HAVE_SSE
|
||
|
|
#error "Selected SSE window decoder but instruction set not supported"
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#include <nmmintrin.h>
|
||
|
|
|
||
|
|
#define WINIMP sse8
|
||
|
|
#define nof_blocks 16
|
||
|
|
|
||
|
|
#define llr_t int8_t
|
||
|
|
|
||
|
|
#define simd_type_t __m128i
|
||
|
|
#define simd_load _mm_load_si128
|
||
|
|
#define simd_store _mm_store_si128
|
||
|
|
#define simd_add _mm_adds_epi8
|
||
|
|
#define simd_sub _mm_subs_epi8
|
||
|
|
#define simd_max _mm_max_epi8
|
||
|
|
#define simd_set1 _mm_set1_epi8
|
||
|
|
#define simd_insert _mm_insert_epi8
|
||
|
|
#define simd_shuffle _mm_shuffle_epi8
|
||
|
|
#define move_right _mm_set_epi8(15,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1)
|
||
|
|
#define move_left _mm_set_epi8(14,13,12,11,10,9,8,7,6,5,4,3,2,1,0,0)
|
||
|
|
#define simd_rb_shift simd_rb_shift_128
|
||
|
|
|
||
|
|
#define normalize_max
|
||
|
|
#define normalize_period 1
|
||
|
|
#define win_overlap_len 40
|
||
|
|
#define use_saturated_add
|
||
|
|
#define divide_output 1
|
||
|
|
|
||
|
|
#define INF 0
|
||
|
|
|
||
|
|
inline static simd_type_t simd_rb_shift_128(simd_type_t v, const int l) {
|
||
|
|
__m128i low = _mm_srai_epi16(_mm_slli_epi16(v,8), l+8);
|
||
|
|
__m128i hi = _mm_srai_epi16(v,l);
|
||
|
|
return _mm_blendv_epi8(hi, low, _mm_set1_epi32(0x00FF00FF));
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
#else
|
||
|
|
|
||
|
|
#ifdef WINIMP_IS_AVX8
|
||
|
|
|
||
|
|
#ifndef LV_HAVE_AVX
|
||
|
|
#error "Selected AVX window decoder but instruction set not supported"
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#include <immintrin.h>
|
||
|
|
|
||
|
|
#define WINIMP avx8
|
||
|
|
#define nof_blocks 32
|
||
|
|
|
||
|
|
#define llr_t int8_t
|
||
|
|
|
||
|
|
#define simd_type_t __m256i
|
||
|
|
#define simd_load _mm256_load_si256
|
||
|
|
#define simd_store _mm256_store_si256
|
||
|
|
#define simd_add _mm256_adds_epi8
|
||
|
|
#define simd_sub _mm256_subs_epi8
|
||
|
|
#define simd_max _mm256_max_epi8
|
||
|
|
#define simd_set1 _mm256_set1_epi8
|
||
|
|
#define simd_insert _mm256_insert_epi8
|
||
|
|
#define simd_shuffle _mm256_shuffle_epi8
|
||
|
|
#define move_right _mm256_set_epi8(31,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1)
|
||
|
|
#define move_left _mm256_set_epi8(30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0,0)
|
||
|
|
#define simd_rb_shift simd_rb_shift_256
|
||
|
|
|
||
|
|
#define INF 0
|
||
|
|
|
||
|
|
#define normalize_max
|
||
|
|
#define normalize_period 1
|
||
|
|
#define win_overlap_len 40
|
||
|
|
#define use_saturated_add
|
||
|
|
#define divide_output 1
|
||
|
|
|
||
|
|
inline static simd_type_t simd_rb_shift_256(simd_type_t v, const int l) {
|
||
|
|
__m256i low = _mm256_srai_epi16(_mm256_slli_epi16(v,8), l+8);
|
||
|
|
__m256i hi = _mm256_srai_epi16(v,l);
|
||
|
|
return _mm256_blendv_epi8(hi, low, _mm256_set1_epi32(0x00FF00FF));
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
#else
|
||
|
|
#error "Unknown WINIMP value"
|
||
|
|
#endif
|
||
|
|
#endif
|
||
|
|
#endif
|
||
|
|
#endif
|
||
|
|
|
||
|
|
typedef struct SRSLTE_API {
|
||
|
|
uint32_t max_long_cb;
|
||
|
|
llr_t *beta;
|
||
|
|
} MAKE_TYPE;
|
||
|
|
|
||
|
|
|
||
|
|
#define long_sb (long_cb/nof_blocks)
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
#define debug_enabled_win 0
|
||
|
|
|
||
|
|
#if debug_enabled_win
|
||
|
|
#define debug_state(d) printf("k=%5d, in=%5d, pa=%3d, out=%5d, alpha=[", d*long_sb+k+1, MAKE_FUNC(get_simd)(x,d), MAKE_FUNC(get_simd)(y,d), MAKE_FUNC(get_simd)(out,d)); \
|
||
|
|
for (int j=0;j<8;j++) printf("%5d, ", MAKE_FUNC(get_simd)(old[j],d)); \
|
||
|
|
printf("], beta=["); \
|
||
|
|
for (int j=0;j<8;j++) printf("%5d, ", MAKE_FUNC(get_simd)(beta_save[j], d));printf("\n");
|
||
|
|
|
||
|
|
#define debug_state_pre(d) printf("pre-window k=%5d, in=%5d, pa=%3d, alpha=[", (d+1)*long_sb-loop_len+k+1, MAKE_FUNC(get_simd)(x,d), MAKE_FUNC(get_simd)(y,d)); \
|
||
|
|
for (int j=0;j<8;j++) printf("%5d, ", MAKE_FUNC(get_simd)(old[j],d)); \
|
||
|
|
printf("]\n");
|
||
|
|
|
||
|
|
#define debug_state_beta(d) printf("k=%5d, in=%5d, pa=%3d, beta=[", d*long_sb+k, MAKE_FUNC(get_simd)(x,d), MAKE_FUNC(get_simd)(y,d)); \
|
||
|
|
for (int j=0;j<8;j++) printf("%5d, ", MAKE_FUNC(get_simd)(old[j],d));\
|
||
|
|
printf("\n");
|
||
|
|
|
||
|
|
static llr_t MAKE_FUNC(get_simd)(simd_type_t x, uint32_t pos) {
|
||
|
|
llr_t *s = (llr_t*) &x;
|
||
|
|
return s[pos];
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
#else
|
||
|
|
#define debug_state(a)
|
||
|
|
#define debug_state_pre(a)
|
||
|
|
#define debug_state_beta(a)
|
||
|
|
#endif
|
||
|
|
/*
|
||
|
|
static void MAKE_FUNC(print_simd)(simd_type_t x) {
|
||
|
|
llr_t *s = (llr_t*) &x;
|
||
|
|
printf("[");
|
||
|
|
for (int i=0;i<nof_blocks;i++) {
|
||
|
|
printf("%4d, ", s[i]);
|
||
|
|
}
|
||
|
|
printf("]\n");
|
||
|
|
}*/
|
||
|
|
|
||
|
|
inline static llr_t MAKE_FUNC(sadd)(llr_t x, llr_t y) {
|
||
|
|
#ifndef use_saturated_add
|
||
|
|
return x+y;
|
||
|
|
#else
|
||
|
|
int16_t z = (int16_t) x+y;
|
||
|
|
return z>127?127:(int8_t) z;
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
inline static void MAKE_FUNC(normalize)(uint32_t k, simd_type_t old[8]) {
|
||
|
|
if ((k % normalize_period) == 0 && k != 0) {
|
||
|
|
#ifdef normalize_max
|
||
|
|
simd_type_t m = simd_max(old[0],old[1]);
|
||
|
|
for (int i=2;i<8;i++) {
|
||
|
|
m = simd_max(m,old[i]);
|
||
|
|
}
|
||
|
|
for (int i=0;i<8;i++) {
|
||
|
|
old[i] = simd_sub(old[i], m);
|
||
|
|
}
|
||
|
|
#else
|
||
|
|
for (int i = 1; i < 8; i++) {
|
||
|
|
old[i] = simd_sub(old[i], old[0]);
|
||
|
|
}
|
||
|
|
old[0] = simd_set1(0);
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static void MAKE_FUNC(beta_trellis)(llr_t *input, llr_t *parity, uint32_t long_cb, llr_t old[8])
|
||
|
|
{
|
||
|
|
llr_t m_b[8], new[8];
|
||
|
|
llr_t x, y, xy;
|
||
|
|
|
||
|
|
/* Calculate last state using Tail. No need to use SIMD here */
|
||
|
|
old[0] = 0;
|
||
|
|
for (int i = 1; i < 8; i++) {
|
||
|
|
old[i] = -INF;
|
||
|
|
}
|
||
|
|
for (int k=long_cb+2;k >= long_cb; k--) {
|
||
|
|
x = input[k];
|
||
|
|
y = parity[k];
|
||
|
|
|
||
|
|
xy = MAKE_FUNC(sadd)(x, y);
|
||
|
|
|
||
|
|
m_b[0] = MAKE_FUNC(sadd)(old[4],xy);
|
||
|
|
m_b[1] = old[4];
|
||
|
|
m_b[2] = MAKE_FUNC(sadd)(old[5], y);
|
||
|
|
m_b[3] = MAKE_FUNC(sadd)(old[5], x);
|
||
|
|
m_b[4] = MAKE_FUNC(sadd)(old[6], x);
|
||
|
|
m_b[5] = MAKE_FUNC(sadd)(old[6], y);
|
||
|
|
m_b[6] = old[7];
|
||
|
|
m_b[7] = MAKE_FUNC(sadd)(old[7], xy);
|
||
|
|
|
||
|
|
new[0] = old[0];
|
||
|
|
new[1] = MAKE_FUNC(sadd)(old[0], xy);
|
||
|
|
new[2] = MAKE_FUNC(sadd)(old[1], x);
|
||
|
|
new[3] = MAKE_FUNC(sadd)(old[1], y);
|
||
|
|
new[4] = MAKE_FUNC(sadd)(old[2], y);
|
||
|
|
new[5] = MAKE_FUNC(sadd)(old[2], x);
|
||
|
|
new[6] = MAKE_FUNC(sadd)(old[3], xy);
|
||
|
|
new[7] = old[3];
|
||
|
|
|
||
|
|
#if debug_enabled_win
|
||
|
|
printf("trellis: k=%d, in=%d, pa=%d, beta: ", k, x, y); for (int i=0;i<8;i++) {printf("%d,", old[i]);} printf("\n");
|
||
|
|
#endif
|
||
|
|
|
||
|
|
for (int i = 0; i < 8; i++) {
|
||
|
|
if (m_b[i] > new[i])
|
||
|
|
new[i] = m_b[i];
|
||
|
|
old[i] = new[i];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Computes beta values */
|
||
|
|
static void MAKE_FUNC(beta)(MAKE_TYPE * s, llr_t *input, llr_t *app, llr_t *parity, uint32_t long_cb)
|
||
|
|
{
|
||
|
|
simd_type_t m_b[8], new[8], old[8];
|
||
|
|
simd_type_t x, y, xy, ap;
|
||
|
|
|
||
|
|
simd_type_t *inputPtr;
|
||
|
|
simd_type_t *appPtr;
|
||
|
|
simd_type_t *parityPtr;
|
||
|
|
simd_type_t *betaPtr = (simd_type_t*) s->beta;
|
||
|
|
|
||
|
|
uint32_t loop_len;
|
||
|
|
for (int j=0;j<2;j++) {
|
||
|
|
|
||
|
|
// First run L states to find initial state for all sub-blocks after first
|
||
|
|
if (j==0) {
|
||
|
|
loop_len = win_overlap_len;
|
||
|
|
} else {
|
||
|
|
loop_len = long_sb;
|
||
|
|
}
|
||
|
|
|
||
|
|
// When passing through all window pick estimated initial states (known state for sb=0)
|
||
|
|
if (loop_len == long_sb) {
|
||
|
|
|
||
|
|
// shuffle across 128-bit boundary manually
|
||
|
|
#ifdef WINIMP_IS_AVX16
|
||
|
|
llr_t tmp[8];
|
||
|
|
for (int i = 0; i < 8; i++) {
|
||
|
|
tmp[i] = _mm256_extract_epi16(old[i], 8);
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
#ifdef WINIMP_IS_AVX8
|
||
|
|
llr_t tmp[8];
|
||
|
|
for (int i = 0; i < 8; i++) {
|
||
|
|
tmp[i] = _mm256_extract_epi8(old[i], 16);
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
for (int i = 0; i < 8; i++) {
|
||
|
|
old[i] = simd_shuffle(old[i], move_right);
|
||
|
|
}
|
||
|
|
// last sub-block state is calculated from the trellis
|
||
|
|
llr_t trellis_old[8];
|
||
|
|
MAKE_FUNC(beta_trellis)(input, parity, long_cb, trellis_old);
|
||
|
|
for (int i = 0; i < 8; i++) {
|
||
|
|
old[i] = simd_insert(old[i], trellis_old[i], nof_blocks-1);
|
||
|
|
}
|
||
|
|
|
||
|
|
#ifdef WINIMP_IS_AVX16
|
||
|
|
for (int i = 0; i < 8; i++) {
|
||
|
|
old[i] = _mm256_insert_epi16(old[i], tmp[i], 7);
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
#ifdef WINIMP_IS_AVX8
|
||
|
|
for (int i = 0; i < 8; i++) {
|
||
|
|
old[i] = _mm256_insert_epi8(old[i], tmp[i], 15);
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
inputPtr = (simd_type_t*) &input[long_cb-nof_blocks];
|
||
|
|
appPtr = (simd_type_t*) &app[long_cb-nof_blocks];
|
||
|
|
parityPtr = (simd_type_t*) &parity[long_cb-nof_blocks];
|
||
|
|
|
||
|
|
for (int i = 0; i < 8; i++) {
|
||
|
|
simd_store(&betaPtr[8*long_sb + i], old[i]);
|
||
|
|
}
|
||
|
|
|
||
|
|
} else {
|
||
|
|
// when estimating states, just set all to unknown
|
||
|
|
for (int i = 0; i < 8; i++) {
|
||
|
|
old[i] = simd_set1(-INF);
|
||
|
|
}
|
||
|
|
inputPtr = (simd_type_t*) &input[nof_blocks*(loop_len-1)];
|
||
|
|
appPtr = (simd_type_t*) &app[nof_blocks*(loop_len-1)];
|
||
|
|
parityPtr = (simd_type_t*) &parity[nof_blocks*(loop_len-1)];
|
||
|
|
}
|
||
|
|
|
||
|
|
for (int k = loop_len - 1; k >= 0; k--) {
|
||
|
|
x = simd_load(inputPtr--);
|
||
|
|
y = simd_load(parityPtr--);
|
||
|
|
|
||
|
|
if (app) {
|
||
|
|
ap = simd_load(appPtr--);
|
||
|
|
x = simd_add(ap, x);
|
||
|
|
}
|
||
|
|
|
||
|
|
xy = simd_add(x, y);
|
||
|
|
|
||
|
|
m_b[0] = simd_add(old[4], xy);
|
||
|
|
m_b[1] = old[4];
|
||
|
|
m_b[2] = simd_add(old[5], y);
|
||
|
|
m_b[3] = simd_add(old[5], x);
|
||
|
|
m_b[4] = simd_add(old[6], x);
|
||
|
|
m_b[5] = simd_add(old[6], y);
|
||
|
|
m_b[6] = old[7];
|
||
|
|
m_b[7] = simd_add(old[7], xy);
|
||
|
|
|
||
|
|
new[0] = old[0];
|
||
|
|
new[1] = simd_add(old[0], xy);
|
||
|
|
new[2] = simd_add(old[1], x);
|
||
|
|
new[3] = simd_add(old[1], y);
|
||
|
|
new[4] = simd_add(old[2], y);
|
||
|
|
new[5] = simd_add(old[2], x);
|
||
|
|
new[6] = simd_add(old[3], xy);
|
||
|
|
new[7] = old[3];
|
||
|
|
|
||
|
|
// Calculate maximum metric
|
||
|
|
for (int i = 0; i < 8; i++) {
|
||
|
|
old[i] = simd_max(m_b[i], new[i]);
|
||
|
|
}
|
||
|
|
// Store metric only when doing the final pass
|
||
|
|
if (loop_len == long_sb) {
|
||
|
|
for (int i = 0; i < 8; i++) {
|
||
|
|
simd_store(&betaPtr[8*k + i], old[i]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (loop_len!=long_sb) {
|
||
|
|
debug_state_beta(0);
|
||
|
|
} else {
|
||
|
|
debug_state_beta(0);
|
||
|
|
}
|
||
|
|
|
||
|
|
// normalize
|
||
|
|
MAKE_FUNC(normalize)(k, old);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Computes alpha metrics */
|
||
|
|
static void MAKE_FUNC(alpha)(MAKE_TYPE * s, llr_t *input, llr_t *app, llr_t *parity, llr_t * output, uint32_t long_cb)
|
||
|
|
{
|
||
|
|
simd_type_t m_b[8], new[8], old[8], max1[8], max0[8];
|
||
|
|
simd_type_t x, y, xy, ap;
|
||
|
|
simd_type_t m1, m0;
|
||
|
|
|
||
|
|
simd_type_t *inputPtr;
|
||
|
|
simd_type_t *appPtr;
|
||
|
|
simd_type_t *parityPtr;
|
||
|
|
simd_type_t *betaPtr = (simd_type_t*) s->beta;
|
||
|
|
simd_type_t *outputPtr = (simd_type_t*) output;
|
||
|
|
|
||
|
|
#if debug_enabled_win
|
||
|
|
simd_type_t beta_save[8];
|
||
|
|
#endif
|
||
|
|
|
||
|
|
// Skip state 0
|
||
|
|
betaPtr+=8;
|
||
|
|
|
||
|
|
uint32_t loop_len;
|
||
|
|
|
||
|
|
for (int j=0;j<2;j++) {
|
||
|
|
|
||
|
|
// First run L states to find initial state for all sub-blocks after first
|
||
|
|
if (j==0) {
|
||
|
|
loop_len = win_overlap_len;
|
||
|
|
} else {
|
||
|
|
loop_len = long_sb;
|
||
|
|
}
|
||
|
|
|
||
|
|
// When passing through all window pick estimated initial states (known state for sb=0)
|
||
|
|
if (loop_len == long_sb) {
|
||
|
|
|
||
|
|
#ifdef WINIMP_IS_AVX16
|
||
|
|
llr_t tmp[8];
|
||
|
|
for (int i=0;i<8;i++) {
|
||
|
|
tmp[i] = _mm256_extract_epi16(old[i], 7);
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
#ifdef WINIMP_IS_AVX8
|
||
|
|
llr_t tmp[8];
|
||
|
|
for (int i=0;i<8;i++) {
|
||
|
|
tmp[i] = _mm256_extract_epi8(old[i], 15);
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
for (int i = 0; i < 8; i++) {
|
||
|
|
old[i] = simd_shuffle(old[i], move_left);
|
||
|
|
}
|
||
|
|
#ifdef WINIMP_IS_AVX16
|
||
|
|
for (int i=0;i<8;i++) {
|
||
|
|
old[i] = _mm256_insert_epi16(old[i], tmp[i], 8);
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
#ifdef WINIMP_IS_AVX8
|
||
|
|
for (int i=0;i<8;i++) {
|
||
|
|
old[i] = _mm256_insert_epi8(old[i], tmp[i], 16);
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
// 1st sub-block state is known
|
||
|
|
old[0] = simd_insert(old[0], 0, 0);
|
||
|
|
for (int i = 1; i < 8; i++) {
|
||
|
|
old[i] = simd_insert(old[i], -INF, 0);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
// when estimating states, just set all to unknown
|
||
|
|
for (int i = 0; i < 8; i++) {
|
||
|
|
old[i] = simd_set1(-INF);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
inputPtr = (simd_type_t*) &input[nof_blocks*(long_sb-loop_len)];
|
||
|
|
appPtr = (simd_type_t*) &app[nof_blocks*(long_sb-loop_len)];
|
||
|
|
parityPtr = (simd_type_t*) &parity[nof_blocks*(long_sb-loop_len)];
|
||
|
|
|
||
|
|
for (int k = 0; k < loop_len; k++) {
|
||
|
|
x = simd_load(inputPtr++);
|
||
|
|
y = simd_load(parityPtr++);
|
||
|
|
|
||
|
|
if (app) {
|
||
|
|
ap = simd_load(appPtr++);
|
||
|
|
x = simd_add(ap, x);
|
||
|
|
}
|
||
|
|
|
||
|
|
xy = simd_add(x,y);
|
||
|
|
|
||
|
|
m_b[0] = old[0];
|
||
|
|
m_b[1] = simd_add(old[3], y);
|
||
|
|
m_b[2] = simd_add(old[4], y);
|
||
|
|
m_b[3] = old[7];
|
||
|
|
m_b[4] = old[1];
|
||
|
|
m_b[5] = simd_add(old[2], y);
|
||
|
|
m_b[6] = simd_add(old[5], y);
|
||
|
|
m_b[7] = old[6];
|
||
|
|
|
||
|
|
new[0] = simd_add(old[1], xy);
|
||
|
|
new[1] = simd_add(old[2], x);
|
||
|
|
new[2] = simd_add(old[5], x);
|
||
|
|
new[3] = simd_add(old[6], xy);
|
||
|
|
new[4] = simd_add(old[0], xy);
|
||
|
|
new[5] = simd_add(old[3], x);
|
||
|
|
new[6] = simd_add(old[4], x);
|
||
|
|
new[7] = simd_add(old[7], xy);
|
||
|
|
|
||
|
|
// Load beta and compute output only when passing through all window
|
||
|
|
if (loop_len == long_sb) {
|
||
|
|
simd_type_t beta;
|
||
|
|
for (int i = 0; i < 8; i++) {
|
||
|
|
beta = simd_load(betaPtr++);
|
||
|
|
max0[i] = simd_add(beta, m_b[i]);
|
||
|
|
max1[i] = simd_add(beta, new[i]);
|
||
|
|
|
||
|
|
#if debug_enabled_win
|
||
|
|
beta_save[i] = beta;
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
m1 = simd_max(max1[0], max1[1]);
|
||
|
|
m0 = simd_max(max0[0], max0[1]);
|
||
|
|
|
||
|
|
for (int i = 2; i < 8; i++) {
|
||
|
|
m1 = simd_max(m1, max1[i]);
|
||
|
|
m0 = simd_max(m0, max0[i]);
|
||
|
|
}
|
||
|
|
|
||
|
|
simd_type_t out = simd_sub(m1, m0);
|
||
|
|
|
||
|
|
// Divide output when using 8-bit arithmetic
|
||
|
|
#ifdef divide_output
|
||
|
|
out = simd_rb_shift(out, divide_output);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
simd_store(outputPtr++, out);
|
||
|
|
|
||
|
|
debug_state(0);
|
||
|
|
}
|
||
|
|
|
||
|
|
for (int i = 0; i < 8; i++) {
|
||
|
|
old[i] = simd_max(m_b[i], new[i]);
|
||
|
|
}
|
||
|
|
|
||
|
|
// normalize
|
||
|
|
MAKE_FUNC(normalize)(k, old);
|
||
|
|
|
||
|
|
if (loop_len != long_sb) {
|
||
|
|
debug_state_pre(0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
int MAKE_FUNC(init)(void **hh, uint32_t max_long_cb)
|
||
|
|
{
|
||
|
|
*hh = calloc(1, sizeof(MAKE_TYPE));
|
||
|
|
|
||
|
|
MAKE_TYPE *h = (MAKE_TYPE*) *hh;
|
||
|
|
|
||
|
|
h->beta = srslte_vec_malloc(sizeof(llr_t) * 8 * max_long_cb * nof_blocks);
|
||
|
|
if (!h->beta) {
|
||
|
|
perror("srslte_vec_malloc");
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
h->max_long_cb = max_long_cb;
|
||
|
|
return nof_blocks;
|
||
|
|
}
|
||
|
|
|
||
|
|
void MAKE_FUNC(free)(void *hh)
|
||
|
|
{
|
||
|
|
MAKE_TYPE *h = (MAKE_TYPE*) hh;
|
||
|
|
if (h->beta) {
|
||
|
|
free(h->beta);
|
||
|
|
}
|
||
|
|
bzero(h, sizeof(MAKE_TYPE));
|
||
|
|
}
|
||
|
|
|
||
|
|
void MAKE_FUNC(dec)(void *hh, llr_t *input, llr_t *app, llr_t *parity, llr_t *output, uint32_t long_cb)
|
||
|
|
{
|
||
|
|
MAKE_TYPE *h = (MAKE_TYPE*) hh;
|
||
|
|
MAKE_FUNC(beta)(h, input, app, parity, long_cb);
|
||
|
|
MAKE_FUNC(alpha)(h, input, app, parity, output, long_cb);
|
||
|
|
#if debug_enabled_win
|
||
|
|
printf("running win decoder: %s\n", STRING(WINIMP));
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
#define INSERT8_INPUT(reg, st, off) reg = simd_insert(reg, input[3*(i+(st+0)*long_sb)+off], st+0);\
|
||
|
|
reg = simd_insert(reg, input[3*(i+(st+1)*long_sb)+off], st+1);\
|
||
|
|
reg = simd_insert(reg, input[3*(i+(st+2)*long_sb)+off], st+2);\
|
||
|
|
reg = simd_insert(reg, input[3*(i+(st+3)*long_sb)+off], st+3);\
|
||
|
|
reg = simd_insert(reg, input[3*(i+(st+4)*long_sb)+off], st+4);\
|
||
|
|
reg = simd_insert(reg, input[3*(i+(st+5)*long_sb)+off], st+5);\
|
||
|
|
reg = simd_insert(reg, input[3*(i+(st+6)*long_sb)+off], st+6);\
|
||
|
|
reg = simd_insert(reg, input[3*(i+(st+7)*long_sb)+off], st+7);
|
||
|
|
|
||
|
|
|
||
|
|
void MAKE_FUNC(extract_input)(llr_t *input, llr_t *systematic, llr_t *app2, llr_t *parity_0, llr_t *parity_1, uint32_t long_cb)
|
||
|
|
{
|
||
|
|
simd_type_t *systPtr = (simd_type_t*) systematic;
|
||
|
|
simd_type_t *parity0Ptr = (simd_type_t*) parity_0;
|
||
|
|
simd_type_t *parity1Ptr = (simd_type_t*) parity_1;
|
||
|
|
|
||
|
|
simd_type_t syst, parity0, parity1;
|
||
|
|
|
||
|
|
for (int i=0;i<long_sb;i++) {
|
||
|
|
INSERT8_INPUT(syst, 0, 0);
|
||
|
|
INSERT8_INPUT(parity0, 0, 1);
|
||
|
|
INSERT8_INPUT(parity1, 0, 2);
|
||
|
|
|
||
|
|
#if nof_blocks >= 16
|
||
|
|
INSERT8_INPUT(syst, 8, 0);
|
||
|
|
INSERT8_INPUT(parity0, 8, 1);
|
||
|
|
INSERT8_INPUT(parity1, 8, 2);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#if nof_blocks >= 32
|
||
|
|
INSERT8_INPUT(syst, 16, 0);
|
||
|
|
INSERT8_INPUT(parity0, 16, 1);
|
||
|
|
INSERT8_INPUT(parity1, 16, 2);
|
||
|
|
INSERT8_INPUT(syst, 24, 0);
|
||
|
|
INSERT8_INPUT(parity0, 24, 1);
|
||
|
|
INSERT8_INPUT(parity1, 24, 2);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
simd_store(systPtr++, syst);
|
||
|
|
simd_store(parity0Ptr++, parity0);
|
||
|
|
simd_store(parity1Ptr++, parity1);
|
||
|
|
}
|
||
|
|
|
||
|
|
for (int i = long_cb; i < long_cb + 3; i++) {
|
||
|
|
systematic[i] = input[3*long_cb + 2*(i - long_cb)];
|
||
|
|
parity_0[i] = input[3*long_cb + 2*(i - long_cb) + 1];
|
||
|
|
|
||
|
|
app2[i] = input[3*long_cb + 6 + 2*(i - long_cb)];
|
||
|
|
parity_1[i] = input[3*long_cb + 6 + 2*(i - long_cb) + 1];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
#define deinter(x,win) ((x%(long_cb/win))*(win)+x/(long_cb/win))
|
||
|
|
|
||
|
|
#define reset_cnt(a,b) if(!((a+1)%b)) { \
|
||
|
|
k+=b*nof_blocks; \
|
||
|
|
if (k >= long_cb) { \
|
||
|
|
k -= (long_cb-1);\
|
||
|
|
}\
|
||
|
|
}
|
||
|
|
#define insert_bit(a,b) ap = _mm_insert_epi16(ap, app1[k+(a%b)*nof_blocks], 7-a); \
|
||
|
|
reset_cnt(a,b); \
|
||
|
|
|
||
|
|
|
||
|
|
#define decide_for(b) for (uint32_t i = 0; i < long_cb/8; i++) { \
|
||
|
|
insert_bit(0,b);\
|
||
|
|
insert_bit(1,b);\
|
||
|
|
insert_bit(2,b);\
|
||
|
|
insert_bit(3,b);\
|
||
|
|
insert_bit(4,b);\
|
||
|
|
insert_bit(5,b);\
|
||
|
|
insert_bit(6,b);\
|
||
|
|
insert_bit(7,b);\
|
||
|
|
output[i] = (uint8_t) _mm_movemask_epi8(_mm_cmpgt_epi8(_mm_packs_epi16(ap,zeros),zeros));\
|
||
|
|
}
|
||
|
|
|
||
|
|
/* No improvement to use AVX here */
|
||
|
|
void MAKE_FUNC(decision_byte)(llr_t *app1, uint8_t *output, uint32_t long_cb)
|
||
|
|
{
|
||
|
|
uint32_t k=0;
|
||
|
|
__m128i zeros = _mm_setzero_si128();
|
||
|
|
__m128i ap;
|
||
|
|
|
||
|
|
if ((long_cb%(nof_blocks*8)) == 0) {
|
||
|
|
decide_for(8);
|
||
|
|
} else if ((long_cb%(nof_blocks*4)) == 0) {
|
||
|
|
decide_for(4);
|
||
|
|
} else if ((long_cb%(nof_blocks*2)) == 0) {
|
||
|
|
decide_for(2);
|
||
|
|
} else {
|
||
|
|
decide_for(1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
#undef WINIMP
|
||
|
|
#undef nof_blocks
|
||
|
|
#undef llr_t
|
||
|
|
#undef normalize_period
|
||
|
|
#undef INF
|
||
|
|
#undef win_overlap_len
|
||
|
|
#undef simd_type_t
|
||
|
|
#undef simd_load
|
||
|
|
#undef simd_store
|
||
|
|
#undef simd_add
|
||
|
|
#undef simd_sub
|
||
|
|
#undef simd_max
|
||
|
|
#undef simd_set1
|
||
|
|
#undef simd_insert
|
||
|
|
#undef simd_shuffle
|
||
|
|
#undef move_right
|
||
|
|
#undef move_left
|
||
|
|
#undef debug_enabled_win
|
||
|
|
|
||
|
|
#ifdef normalize_max
|
||
|
|
#undef normalize_max
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#ifdef use_saturated_add
|
||
|
|
#undef use_saturated_add
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#ifdef simd_rb_shift
|
||
|
|
#undef simd_rb_shift
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#ifdef divide_output
|
||
|
|
#undef divide_output
|
||
|
|
#endif
|