diff --git a/openair1/PHY/CODING/TESTBENCH/ldpctest.c b/openair1/PHY/CODING/TESTBENCH/ldpctest.c index 14652e339c..8229862abf 100644 --- a/openair1/PHY/CODING/TESTBENCH/ldpctest.c +++ b/openair1/PHY/CODING/TESTBENCH/ldpctest.c @@ -157,7 +157,9 @@ int test_ldpc(short No_iteration, //double code_rate_actual_vec[8] = {0.2, 0.33333, 0.4, 0.5, 0.66667, 0.73333, 0.81481, 0.88}; t_nrLDPC_dec_params decParams; - + t_nrLDPC_procBuf nrLDPC_procBuf; + t_nrLDPC_procBuf* p_nrLDPC_procBuf = &nrLDPC_procBuf; + t_nrLDPC_time_stats decoder_profiler; t_nrLDPC_time_stats* p_decoder_profiler =&decoder_profiler ; @@ -210,6 +212,9 @@ int test_ldpc(short No_iteration, reset_meas(&decoder_profiler.llr2bit); //reset_meas(&decoder_profiler.total); + // Allocate LDPC decoder buffers + p_nrLDPC_procBuf = nrLDPC_init_mem(); + for (j=0;jnumBnInBnGroups; const uint32_t* lut_startAddrBnGroups = p_lut->startAddrBnGroups; const uint16_t* lut_startAddrBnGroupsLlr = p_lut->startAddrBnGroupsLlr; + int8_t* bnProcBuf = p_procBuf->bnProcBuf; + int8_t* bnProcBufRes = p_procBuf->bnProcBufRes; + int8_t* llrRes = p_procBuf->llrRes; + int8_t* llrProcBuf = p_procBuf->llrProcBuf; + __m128i* p_bnProcBuf; __m256i* p_bnProcBufRes; __m128i* p_llrProcBuf; @@ -1676,7 +1681,7 @@ static inline void nrLDPC_bnProcPc(t_nrLDPC_lut* p_lut, uint16_t Z) \param p_lut Pointer to decoder LUTs \param Z Lifting size */ -static inline void nrLDPC_bnProc(t_nrLDPC_lut* p_lut, uint16_t Z) +static inline void nrLDPC_bnProc(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf* p_procBuf, uint16_t Z) { // BN Processing calculating the values to send back to the CNs for next iteration // bnProcBufRes contains the sum of all edges to each BN at the start of each group @@ -1685,6 +1690,10 @@ static inline void nrLDPC_bnProc(t_nrLDPC_lut* p_lut, uint16_t Z) const uint32_t* lut_startAddrBnGroups = p_lut->startAddrBnGroups; const uint16_t* lut_startAddrBnGroupsLlr = p_lut->startAddrBnGroupsLlr; + int8_t* bnProcBuf = p_procBuf->bnProcBuf; + int8_t* bnProcBufRes = p_procBuf->bnProcBufRes; + int8_t* llrRes = p_procBuf->llrRes; + __m256i* p_bnProcBuf; __m256i* p_bnProcBufRes; __m256i* p_llrRes; diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_cnProc.h b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_cnProc.h index 300624ae76..5b96d6226e 100644 --- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_cnProc.h +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_cnProc.h @@ -36,11 +36,14 @@ \param p_lut Pointer to decoder LUTs \param Z Lifting size */ -static inline void nrLDPC_cnProc_BG2(t_nrLDPC_lut* p_lut, uint16_t Z) +static inline void nrLDPC_cnProc_BG2(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf* p_procBuf, uint16_t Z) { const uint8_t* lut_numCnInCnGroups = p_lut->numCnInCnGroups; const uint32_t* lut_startAddrCnGroups = p_lut->startAddrCnGroups; + int8_t* cnProcBuf = p_procBuf->cnProcBuf; + int8_t* cnProcBufRes = p_procBuf->cnProcBufRes; + __m256i* p_cnProcBuf; __m256i* p_cnProcBufRes; @@ -362,11 +365,14 @@ static inline void nrLDPC_cnProc_BG2(t_nrLDPC_lut* p_lut, uint16_t Z) \param p_lut Pointer to decoder LUTs \param Z Lifting size */ -static inline void nrLDPC_cnProc_BG1(t_nrLDPC_lut* p_lut, uint16_t Z) +static inline void nrLDPC_cnProc_BG1(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf* p_procBuf, uint16_t Z) { const uint8_t* lut_numCnInCnGroups = p_lut->numCnInCnGroups; const uint32_t* lut_startAddrCnGroups = p_lut->startAddrCnGroups; + int8_t* cnProcBuf = p_procBuf->cnProcBuf; + int8_t* cnProcBufRes = p_procBuf->cnProcBufRes; + __m256i* p_cnProcBuf; __m256i* p_cnProcBufRes; @@ -858,11 +864,14 @@ static inline void nrLDPC_cnProc_BG1(t_nrLDPC_lut* p_lut, uint16_t Z) \param Z Lifting size \return 32-bit parity check indicator */ -static inline uint32_t nrLDPC_cnProcPc_BG1(t_nrLDPC_lut* p_lut, uint16_t Z) +static inline uint32_t nrLDPC_cnProcPc_BG1(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf* p_procBuf, uint16_t Z) { const uint8_t* lut_numCnInCnGroups = p_lut->numCnInCnGroups; const uint32_t* lut_startAddrCnGroups = p_lut->startAddrCnGroups; + int8_t* cnProcBuf = p_procBuf->cnProcBuf; + int8_t* cnProcBufRes = p_procBuf->cnProcBufRes; + __m256i* p_cnProcBuf; __m256i* p_cnProcBufRes; @@ -1490,11 +1499,14 @@ static inline uint32_t nrLDPC_cnProcPc_BG1(t_nrLDPC_lut* p_lut, uint16_t Z) \param Z Lifting size \return 32-bit parity check indicator */ -static inline uint32_t nrLDPC_cnProcPc_BG2(t_nrLDPC_lut* p_lut, uint16_t Z) +static inline uint32_t nrLDPC_cnProcPc_BG2(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf* p_procBuf, uint16_t Z) { const uint8_t* lut_numCnInCnGroups = p_lut->numCnInCnGroups; const uint32_t* lut_startAddrCnGroups = p_lut->startAddrCnGroups; + int8_t* cnProcBuf = p_procBuf->cnProcBuf; + int8_t* cnProcBufRes = p_procBuf->cnProcBufRes; + __m256i* p_cnProcBuf; __m256i* p_cnProcBufRes; diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.c index fbdb9a3fa4..bbcd34c368 100644 --- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.c +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.c @@ -45,20 +45,22 @@ #include "nrLDPC_tools/nrLDPC_debug.h" #endif -static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, uint32_t numLLR, t_nrLDPC_lut* p_lut, t_nrLDPC_dec_params* p_decParams, t_nrLDPC_time_stats* p_profiler); +static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDPC_procBuf* p_procBuf, uint32_t numLLR, t_nrLDPC_lut* p_lut, t_nrLDPC_dec_params* p_decParams, t_nrLDPC_time_stats* p_profiler); -int32_t nrLDPC_decoder(t_nrLDPC_dec_params* p_decParams, int8_t* p_llr, int8_t* p_out, t_nrLDPC_time_stats* p_profiler) +int32_t nrLDPC_decoder(t_nrLDPC_dec_params* p_decParams, int8_t* p_llr, int8_t* p_out, t_nrLDPC_procBuf* p_procBuf, t_nrLDPC_time_stats* p_profiler) { uint32_t numLLR; uint32_t numIter = 0; t_nrLDPC_lut lut; t_nrLDPC_lut* p_lut = &lut; + printf("p_procBuf->cnProcBuf = %p\n", p_procBuf->cnProcBuf); + // Initialize decoder core(s) with correct LUTs numLLR = nrLDPC_init(p_decParams, p_lut); // Launch LDPC decoder core for one segment - numIter = nrLDPC_decoder_core(p_llr, p_out, numLLR, p_lut, p_decParams, p_profiler); + numIter = nrLDPC_decoder_core(p_llr, p_out, p_procBuf, numLLR, p_lut, p_decParams, p_profiler); return numIter; } @@ -72,7 +74,7 @@ int32_t nrLDPC_decoder(t_nrLDPC_dec_params* p_decParams, int8_t* p_llr, int8_t* \param p_decParams LDPC decoder parameters \param p_profiler LDPC profiler statistics */ -static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, uint32_t numLLR, t_nrLDPC_lut* p_lut, t_nrLDPC_dec_params* p_decParams, t_nrLDPC_time_stats* p_profiler) +static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDPC_procBuf* p_procBuf, uint32_t numLLR, t_nrLDPC_lut* p_lut, t_nrLDPC_dec_params* p_decParams, t_nrLDPC_time_stats* p_profiler) { uint16_t Z = p_decParams->Z; uint8_t BG = p_decParams->BG; @@ -93,7 +95,7 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, uint32_ else { // Use LLR processing buffer as temporary output buffer - p_llrOut = (int8_t*) llrProcBuf; + p_llrOut = p_procBuf->llrProcBuf; } @@ -101,27 +103,27 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, uint32_ #ifdef NR_LDPC_PROFILER_DETAIL start_meas(&p_profiler->llr2llrProcBuf); #endif - nrLDPC_llr2llrProcBuf(p_lut, p_llr, Z, BG); + nrLDPC_llr2llrProcBuf(p_lut, p_llr, p_procBuf, Z, BG); #ifdef NR_LDPC_PROFILER_DETAIL stop_meas(&p_profiler->llr2llrProcBuf); #endif #ifdef NR_LDPC_DEBUG_MODE nrLDPC_debug_initBuffer2File(nrLDPC_buffers_LLR_PROC); - nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_LLR_PROC); + nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_LLR_PROC, p_procBuf); #endif #ifdef NR_LDPC_PROFILER_DETAIL start_meas(&p_profiler->llr2CnProcBuf); #endif - nrLDPC_llr2CnProcBuf(p_lut, p_llr, numLLR, Z, BG); + nrLDPC_llr2CnProcBuf(p_lut, p_llr, p_procBuf, numLLR, Z, BG); #ifdef NR_LDPC_PROFILER_DETAIL stop_meas(&p_profiler->llr2CnProcBuf); #endif #ifdef NR_LDPC_DEBUG_MODE nrLDPC_debug_initBuffer2File(nrLDPC_buffers_CN_PROC); - nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_CN_PROC); + nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_CN_PROC, p_procBuf); #endif // First iteration @@ -132,11 +134,11 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, uint32_ #endif if (BG == 1) { - nrLDPC_cnProc_BG1(p_lut, Z); + nrLDPC_cnProc_BG1(p_lut, p_procBuf, Z); } else { - nrLDPC_cnProc_BG2(p_lut, Z); + nrLDPC_cnProc_BG2(p_lut, p_procBuf, Z); } #ifdef NR_LDPC_PROFILER_DETAIL stop_meas(&p_profiler->cnProc); @@ -144,7 +146,7 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, uint32_ #ifdef NR_LDPC_DEBUG_MODE nrLDPC_debug_initBuffer2File(nrLDPC_buffers_CN_PROC_RES); - nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_CN_PROC_RES); + nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_CN_PROC_RES, p_procBuf); #endif #ifdef NR_LDPC_PROFILER_DETAIL @@ -152,11 +154,11 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, uint32_ #endif if (BG == 1) { - nrLDPC_cn2bnProcBuf_BG1(p_lut, Z); + nrLDPC_cn2bnProcBuf_BG1(p_lut, p_procBuf, Z); } else { - nrLDPC_cn2bnProcBuf(p_lut, Z); + nrLDPC_cn2bnProcBuf(p_lut, p_procBuf, Z); } #ifdef NR_LDPC_PROFILER_DETAIL stop_meas(&p_profiler->cn2bnProcBuf); @@ -164,34 +166,34 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, uint32_ #ifdef NR_LDPC_DEBUG_MODE nrLDPC_debug_initBuffer2File(nrLDPC_buffers_BN_PROC); - nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_BN_PROC); + nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_BN_PROC, p_procBuf); #endif // BN processing #ifdef NR_LDPC_PROFILER_DETAIL start_meas(&p_profiler->bnProcPc); #endif - nrLDPC_bnProcPc(p_lut, Z); + nrLDPC_bnProcPc(p_lut, p_procBuf, Z); #ifdef NR_LDPC_PROFILER_DETAIL stop_meas(&p_profiler->bnProcPc); #endif #ifdef NR_LDPC_DEBUG_MODE nrLDPC_debug_initBuffer2File(nrLDPC_buffers_LLR_RES); - nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_LLR_RES); + nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_LLR_RES, p_procBuf); #endif #ifdef NR_LDPC_PROFILER_DETAIL start_meas(&p_profiler->bnProc); #endif - nrLDPC_bnProc(p_lut, Z); + nrLDPC_bnProc(p_lut, p_procBuf, Z); #ifdef NR_LDPC_PROFILER_DETAIL stop_meas(&p_profiler->bnProc); #endif #ifdef NR_LDPC_DEBUG_MODE nrLDPC_debug_initBuffer2File(nrLDPC_buffers_BN_PROC_RES); - nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_BN_PROC_RES); + nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_BN_PROC_RES, p_procBuf); #endif // BN results to CN processing buffer @@ -200,18 +202,18 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, uint32_ #endif if (BG == 1) { - nrLDPC_bn2cnProcBuf_BG1(p_lut, Z); + nrLDPC_bn2cnProcBuf_BG1(p_lut, p_procBuf, Z); } else { - nrLDPC_bn2cnProcBuf(p_lut, Z); + nrLDPC_bn2cnProcBuf(p_lut, p_procBuf, Z); } #ifdef NR_LDPC_PROFILER_DETAIL stop_meas(&p_profiler->bn2cnProcBuf); #endif #ifdef NR_LDPC_DEBUG_MODE - nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_CN_PROC); + nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_CN_PROC, p_procBuf); #endif // Parity Check not necessary here since it will fail @@ -231,18 +233,18 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, uint32_ #endif if (BG == 1) { - nrLDPC_cnProc_BG1(p_lut, Z); + nrLDPC_cnProc_BG1(p_lut, p_procBuf, Z); } else { - nrLDPC_cnProc_BG2(p_lut, Z); + nrLDPC_cnProc_BG2(p_lut, p_procBuf, Z); } #ifdef NR_LDPC_PROFILER_DETAIL stop_meas(&p_profiler->cnProc); #endif #ifdef NR_LDPC_DEBUG_MODE - nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_CN_PROC_RES); + nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_CN_PROC_RES, p_procBuf); #endif // Send CN results back to BNs @@ -251,43 +253,43 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, uint32_ #endif if (BG == 1) { - nrLDPC_cn2bnProcBuf_BG1(p_lut, Z); + nrLDPC_cn2bnProcBuf_BG1(p_lut, p_procBuf, Z); } else { - nrLDPC_cn2bnProcBuf(p_lut, Z); + nrLDPC_cn2bnProcBuf(p_lut, p_procBuf, Z); } #ifdef NR_LDPC_PROFILER_DETAIL stop_meas(&p_profiler->cn2bnProcBuf); #endif #ifdef NR_LDPC_DEBUG_MODE - nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_BN_PROC); + nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_BN_PROC, p_procBuf); #endif // BN Processing #ifdef NR_LDPC_PROFILER_DETAIL start_meas(&p_profiler->bnProcPc); #endif - nrLDPC_bnProcPc(p_lut, Z); + nrLDPC_bnProcPc(p_lut, p_procBuf, Z); #ifdef NR_LDPC_PROFILER_DETAIL stop_meas(&p_profiler->bnProcPc); #endif #ifdef NR_LDPC_DEBUG_MODE - nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_LLR_RES); + nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_LLR_RES, p_procBuf); #endif #ifdef NR_LDPC_PROFILER_DETAIL start_meas(&p_profiler->bnProc); #endif - nrLDPC_bnProc(p_lut, Z); + nrLDPC_bnProc(p_lut, p_procBuf, Z); #ifdef NR_LDPC_PROFILER_DETAIL stop_meas(&p_profiler->bnProc); #endif #ifdef NR_LDPC_DEBUG_MODE - nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_BN_PROC_RES); + nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_BN_PROC_RES, p_procBuf); #endif // BN results to CN processing buffer @@ -296,18 +298,18 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, uint32_ #endif if (BG == 1) { - nrLDPC_bn2cnProcBuf_BG1(p_lut, Z); + nrLDPC_bn2cnProcBuf_BG1(p_lut, p_procBuf, Z); } else { - nrLDPC_bn2cnProcBuf(p_lut, Z); + nrLDPC_bn2cnProcBuf(p_lut, p_procBuf, Z); } #ifdef NR_LDPC_PROFILER_DETAIL stop_meas(&p_profiler->bn2cnProcBuf); #endif #ifdef NR_LDPC_DEBUG_MODE - nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_CN_PROC); + nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_CN_PROC, p_procBuf); #endif // Parity Check @@ -317,11 +319,11 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, uint32_ #endif if (BG == 1) { - pcRes = nrLDPC_cnProcPc_BG1(p_lut, Z); + pcRes = nrLDPC_cnProcPc_BG1(p_lut, p_procBuf, Z); } else { - pcRes = nrLDPC_cnProcPc_BG2(p_lut, Z); + pcRes = nrLDPC_cnProcPc_BG2(p_lut, p_procBuf, Z); } #ifdef NR_LDPC_PROFILER_DETAIL stop_meas(&p_profiler->cnProcPc); @@ -342,18 +344,18 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, uint32_ #endif if (BG == 1) { - nrLDPC_cnProc_BG1(p_lut, Z); + nrLDPC_cnProc_BG1(p_lut, p_procBuf, Z); } else { - nrLDPC_cnProc_BG2(p_lut, Z); + nrLDPC_cnProc_BG2(p_lut, p_procBuf, Z); } #ifdef NR_LDPC_PROFILER_DETAIL stop_meas(&p_profiler->cnProc); #endif #ifdef NR_LDPC_DEBUG_MODE - nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_CN_PROC_RES); + nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_CN_PROC_RES, p_procBuf); #endif // Send CN results back to BNs @@ -362,31 +364,31 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, uint32_ #endif if (BG == 1) { - nrLDPC_cn2bnProcBuf_BG1(p_lut, Z); + nrLDPC_cn2bnProcBuf_BG1(p_lut, p_procBuf, Z); } else { - nrLDPC_cn2bnProcBuf(p_lut, Z); + nrLDPC_cn2bnProcBuf(p_lut, p_procBuf, Z); } #ifdef NR_LDPC_PROFILER_DETAIL stop_meas(&p_profiler->cn2bnProcBuf); #endif #ifdef NR_LDPC_DEBUG_MODE - nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_BN_PROC); + nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_BN_PROC, p_procBuf); #endif // BN Processing #ifdef NR_LDPC_PROFILER_DETAIL start_meas(&p_profiler->bnProcPc); #endif - nrLDPC_bnProcPc(p_lut, Z); + nrLDPC_bnProcPc(p_lut, p_procBuf, Z); #ifdef NR_LDPC_PROFILER_DETAIL stop_meas(&p_profiler->bnProcPc); #endif #ifdef NR_LDPC_DEBUG_MODE - nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_LLR_RES); + nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_LLR_RES, p_procBuf); #endif // If parity check not enabled, no need to send the BN proc results @@ -395,13 +397,13 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, uint32_ #ifdef NR_LDPC_PROFILER_DETAIL start_meas(&p_profiler->bnProc); #endif - nrLDPC_bnProc(p_lut, Z); + nrLDPC_bnProc(p_lut, p_procBuf, Z); #ifdef NR_LDPC_PROFILER_DETAIL stop_meas(&p_profiler->bnProc); #endif #ifdef NR_LDPC_DEBUG_MODE - nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_BN_PROC_RES); + nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_BN_PROC_RES, p_procBuf); #endif // BN results to CN processing buffer @@ -410,18 +412,18 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, uint32_ #endif if (BG == 1) { - nrLDPC_bn2cnProcBuf_BG1(p_lut, Z); + nrLDPC_bn2cnProcBuf_BG1(p_lut, p_procBuf, Z); } else { - nrLDPC_bn2cnProcBuf(p_lut, Z); + nrLDPC_bn2cnProcBuf(p_lut, p_procBuf, Z); } #ifdef NR_LDPC_PROFILER_DETAIL stop_meas(&p_profiler->bn2cnProcBuf); #endif #ifdef NR_LDPC_DEBUG_MODE - nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_CN_PROC); + nrLDPC_debug_writeBuffer2File(nrLDPC_buffers_CN_PROC, p_procBuf); #endif // Parity Check @@ -430,11 +432,11 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, uint32_ #endif if (BG == 1) { - pcRes = nrLDPC_cnProcPc_BG1(p_lut, Z); + pcRes = nrLDPC_cnProcPc_BG1(p_lut, p_procBuf, Z); } else { - pcRes = nrLDPC_cnProcPc_BG2(p_lut, Z); + pcRes = nrLDPC_cnProcPc_BG2(p_lut, p_procBuf, Z); } #ifdef NR_LDPC_PROFILER_DETAIL stop_meas(&p_profiler->cnProcPc); @@ -454,7 +456,7 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, uint32_ #ifdef NR_LDPC_PROFILER_DETAIL start_meas(&p_profiler->llrRes2llrOut); #endif - nrLDPC_llrRes2llrOut(p_lut, p_llrOut, numLLR); + nrLDPC_llrRes2llrOut(p_lut, p_llrOut, p_procBuf, numLLR); #ifdef NR_LDPC_PROFILER_DETAIL stop_meas(&p_profiler->llrRes2llrOut); #endif diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.h b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.h index e1dff38723..4d2401db83 100644 --- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.h +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.h @@ -32,6 +32,7 @@ #define __NR_LDPC_DECODER__H__ #include "nrLDPC_types.h" +#include "nrLDPC_init_mem.h" /** \brief LDPC decoder @@ -40,6 +41,6 @@ \param p_llrOut Output vector \param p_profiler LDPC profiler statistics */ -int32_t nrLDPC_decoder(t_nrLDPC_dec_params* p_decParams, int8_t* p_llr, int8_t* p_llrOut, t_nrLDPC_time_stats* p_profiler); +int32_t nrLDPC_decoder(t_nrLDPC_dec_params* p_decParams, int8_t* p_llr, int8_t* p_llrOut, t_nrLDPC_procBuf* p_procBuf, t_nrLDPC_time_stats* p_profiler); #endif diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_defs.h b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_defs.h index 6dbd38e681..940d842550 100644 --- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_defs.h +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_defs.h @@ -100,23 +100,7 @@ #define NR_LDPC_MAX_NUM_LLR 26112 // ============================================================================== -// GLOBAL VARIABLES - -// Aligned on 32 bytes = 256 bits for AVX2 -/** CN processing buffer */ -static int8_t cnProcBuf [NR_LDPC_SIZE_CN_PROC_BUF] __attribute__ ((aligned(32))); -/** Buffer for CN processing results */ -static int8_t cnProcBufRes[NR_LDPC_SIZE_CN_PROC_BUF] __attribute__ ((aligned(32))); - -/** BN processing buffer */ -static int8_t bnProcBuf [NR_LDPC_SIZE_BN_PROC_BUF] __attribute__ ((aligned(32))); -/** Buffer for BN processing results */ -static int8_t bnProcBufRes[NR_LDPC_SIZE_BN_PROC_BUF] __attribute__ ((aligned(32))); - -/** Buffer for LLR results */ -static int8_t llrRes [NR_LDPC_MAX_NUM_LLR] __attribute__ ((aligned(32))); -/** LLR processing buffer */ -static int8_t llrProcBuf[NR_LDPC_MAX_NUM_LLR] __attribute__ ((aligned(32))); +// GLOBAL CONSTANT VARIABLES /** Start addresses for the cnProcBuf for each CN group in BG1*/ static const uint32_t lut_startAddrCnGroups_BG1[NR_LDPC_NUM_CN_GROUPS_BG1] = {0, 1152, 8832, 43392, 61824, 75264, 81408, 88320, 92160}; diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_init_mem.h b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_init_mem.h new file mode 100644 index 0000000000..bdaa118e1f --- /dev/null +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_init_mem.h @@ -0,0 +1,86 @@ +/* + * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The OpenAirInterface Software Alliance licenses this file to You under + * the OAI Public License, Version 1.1 (the "License"); you may not use this file + * except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.openairinterface.org/?page_id=698 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + *------------------------------------------------------------------------------- + * For more information about the OpenAirInterface (OAI) Software Alliance: + * contact@openairinterface.org + */ + +/*!\file nrLDPC_init_mem.h + * \brief Defines the function to initialize the LDPC decoder and sets correct LUTs. + * \author Sebastian Wagner (TCL Communications) Email: + * \date 07-12-2018 + * \version 1.0 + * \note + * \warning + */ + +#ifndef __NR_LDPC_INIT_MEM__H__ +#define __NR_LDPC_INIT_MEM__H__ + +#include +#include "nrLDPC_defs.h" +#include "nrLDPC_types.h" + +#ifndef malloc32_clear +/** + \brief Allocates 32 byte aligned memory and initializes to zero + \param size Input size in bytes + \return Pointer to memory +*/ +static inline void* malloc32_clear(size_t size) +{ + void* ptr = (void*) memalign(32, size+32); + memset(ptr, 0, size); + return ptr; +} +#endif + +/** + \brief Allocates and initializes the internal decoder processing buffers + \param p_decParams Pointer to decoder parameters + \param p_lut Pointer to decoder LUTs + \return Number of LLR values +*/ +static inline t_nrLDPC_procBuf* nrLDPC_init_mem(void) +{ + t_nrLDPC_procBuf* p_procBuf = (t_nrLDPC_procBuf*) malloc32_clear(sizeof(t_nrLDPC_procBuf)); + + if (p_procBuf) + { + p_procBuf->cnProcBuf = (int8_t*) malloc32_clear(NR_LDPC_SIZE_CN_PROC_BUF*sizeof(int8_t)); + p_procBuf->cnProcBufRes = (int8_t*) malloc32_clear(NR_LDPC_SIZE_CN_PROC_BUF*sizeof(int8_t)); + p_procBuf->bnProcBuf = (int8_t*) malloc32_clear(NR_LDPC_SIZE_BN_PROC_BUF*sizeof(int8_t)); + p_procBuf->bnProcBufRes = (int8_t*) malloc32_clear(NR_LDPC_SIZE_BN_PROC_BUF*sizeof(int8_t)); + p_procBuf->llrRes = (int8_t*) malloc32_clear(NR_LDPC_MAX_NUM_LLR *sizeof(int8_t)); + p_procBuf->llrProcBuf = (int8_t*) malloc32_clear(NR_LDPC_MAX_NUM_LLR *sizeof(int8_t)); + } + + return(p_procBuf); +} + +static inline void nrLDPC_free_mem(t_nrLDPC_procBuf* p_procBuf) +{ + free(p_procBuf->cnProcBuf); + free(p_procBuf->cnProcBufRes); + free(p_procBuf->bnProcBuf); + free(p_procBuf->bnProcBufRes); + free(p_procBuf->llrRes); + free(p_procBuf->llrProcBuf); + + free(p_procBuf); +} +#endif diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_mPass.h b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_mPass.h index 3e6c4c0c7c..f3431eba24 100644 --- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_mPass.h +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_mPass.h @@ -41,13 +41,15 @@ \param Z Lifting size \param BG Base graph */ -static inline void nrLDPC_llr2llrProcBuf(t_nrLDPC_lut* p_lut, int8_t* llr, uint16_t Z, uint8_t BG) +static inline void nrLDPC_llr2llrProcBuf(t_nrLDPC_lut* p_lut, int8_t* llr, t_nrLDPC_procBuf* p_procBuf, uint16_t Z, uint8_t BG) { const uint16_t* lut_llr2llrProcBuf = p_lut->llr2llrProcBuf; uint32_t i; const uint8_t numBn2CnG1 = p_lut->numBnInBnGroups[0]; uint32_t colG1 = NR_LDPC_START_COL_PARITY_BG1*Z; + int8_t* llrProcBuf = p_procBuf->llrProcBuf; + if (BG == 2) { colG1 = NR_LDPC_START_COL_PARITY_BG2*Z; @@ -74,11 +76,13 @@ static inline void nrLDPC_llr2llrProcBuf(t_nrLDPC_lut* p_lut, int8_t* llr, uint1 \param Z Lifting size \param BG Base graph */ -static inline void nrLDPC_llr2CnProcBuf(t_nrLDPC_lut* p_lut, int8_t* llr, uint16_t numLLR, uint16_t Z, uint8_t BG) +static inline void nrLDPC_llr2CnProcBuf(t_nrLDPC_lut* p_lut, int8_t* llr, t_nrLDPC_procBuf* p_procBuf, uint16_t numLLR, uint16_t Z, uint8_t BG) { const uint32_t* lut_llr2CnProcBuf = p_lut->llr2CnProcBuf; const uint8_t* lut_numEdgesPerBn = p_lut->numEdgesPerBn; + int8_t* cnProcBuf = p_procBuf->cnProcBuf; + int8_t curLLR; uint8_t numEdges; uint32_t i; @@ -123,12 +127,15 @@ static inline void nrLDPC_llr2CnProcBuf(t_nrLDPC_lut* p_lut, int8_t* llr, uint16 \param p_lut Pointer to decoder LUTs \param Z Lifting size */ -static inline void nrLDPC_cn2bnProcBuf(t_nrLDPC_lut* p_lut, uint16_t Z) +static inline void nrLDPC_cn2bnProcBuf(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf* p_procBuf, uint16_t Z) { const uint32_t* lut_cn2bnProcBuf = p_lut->cn2bnProcBuf; const uint8_t* lut_numCnInCnGroups = p_lut->numCnInCnGroups; const uint32_t* lut_startAddrCnGroups = p_lut->startAddrCnGroups; + int8_t* cnProcBufRes = p_procBuf->cnProcBufRes; + int8_t* bnProcBuf = p_procBuf->bnProcBuf; + const uint32_t* p_lut_cn2bn; int8_t* p_cnProcBufRes; uint32_t bitOffsetInGroup; @@ -245,12 +252,15 @@ static inline void nrLDPC_cn2bnProcBuf(t_nrLDPC_lut* p_lut, uint16_t Z) \param p_lut Pointer to decoder LUTs \param Z Lifting size */ -static inline void nrLDPC_cn2bnProcBuf_BG1(t_nrLDPC_lut* p_lut, uint16_t Z) +static inline void nrLDPC_cn2bnProcBuf_BG1(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf* p_procBuf, uint16_t Z) { const uint32_t* lut_cn2bnProcBuf = p_lut->cn2bnProcBuf; const uint8_t* lut_numCnInCnGroups = p_lut->numCnInCnGroups; const uint32_t* lut_startAddrCnGroups = p_lut->startAddrCnGroups; + int8_t* cnProcBufRes = p_procBuf->cnProcBufRes; + int8_t* bnProcBuf = p_procBuf->bnProcBuf; + const uint32_t* p_lut_cn2bn; int8_t* p_cnProcBufRes; uint32_t bitOffsetInGroup; @@ -418,12 +428,15 @@ static inline void nrLDPC_cn2bnProcBuf_BG1(t_nrLDPC_lut* p_lut, uint16_t Z) \param p_lut Pointer to decoder LUTs \param Z Lifting size */ -static inline void nrLDPC_bn2cnProcBuf(t_nrLDPC_lut* p_lut, uint16_t Z) +static inline void nrLDPC_bn2cnProcBuf(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf* p_procBuf, uint16_t Z) { const uint32_t* lut_cn2bnProcBuf = p_lut->cn2bnProcBuf; const uint8_t* lut_numCnInCnGroups = p_lut->numCnInCnGroups; const uint32_t* lut_startAddrCnGroups = p_lut->startAddrCnGroups; + int8_t* cnProcBuf = p_procBuf->cnProcBuf; + int8_t* bnProcBufRes = p_procBuf->bnProcBufRes; + int8_t* p_cnProcBuf; const uint32_t* p_lut_cn2bn; uint32_t bitOffsetInGroup; @@ -543,12 +556,15 @@ static inline void nrLDPC_bn2cnProcBuf(t_nrLDPC_lut* p_lut, uint16_t Z) \param p_lut Pointer to decoder LUTs \param Z Lifting size */ -static inline void nrLDPC_bn2cnProcBuf_BG1(t_nrLDPC_lut* p_lut, uint16_t Z) +static inline void nrLDPC_bn2cnProcBuf_BG1(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf* p_procBuf, uint16_t Z) { const uint32_t* lut_cn2bnProcBuf = p_lut->cn2bnProcBuf; const uint8_t* lut_numCnInCnGroups = p_lut->numCnInCnGroups; const uint32_t* lut_startAddrCnGroups = p_lut->startAddrCnGroups; + int8_t* cnProcBuf = p_procBuf->cnProcBuf; + int8_t* bnProcBufRes = p_procBuf->bnProcBufRes; + int8_t* p_cnProcBuf; const uint32_t* p_lut_cn2bn; uint32_t bitOffsetInGroup; @@ -720,11 +736,13 @@ static inline void nrLDPC_bn2cnProcBuf_BG1(t_nrLDPC_lut* p_lut, uint16_t Z) \param llrOut Pointer to output LLRs \param numLLR Number of LLR values */ -static inline void nrLDPC_llrRes2llrOut(t_nrLDPC_lut* p_lut, int8_t* llrOut, uint16_t numLLR) +static inline void nrLDPC_llrRes2llrOut(t_nrLDPC_lut* p_lut, int8_t* llrOut, t_nrLDPC_procBuf* p_procBuf, uint16_t numLLR) { const uint16_t* lut_llr2llrProcBuf = p_lut->llr2llrProcBuf; uint32_t i; + int8_t* llrRes = p_procBuf->llrRes; + for (i=0; illrProcBuf, NR_LDPC_MAX_NUM_LLR); break; } case nrLDPC_buffers_CN_PROC: { - nrLDPC_writeFile("cnProcBuf.txt", cnProcBuf, NR_LDPC_SIZE_CN_PROC_BUF); + nrLDPC_writeFile("cnProcBuf.txt", p_procBuf->cnProcBuf, NR_LDPC_SIZE_CN_PROC_BUF); break; } case nrLDPC_buffers_CN_PROC_RES: { - nrLDPC_writeFile("cnProcBufRes.txt", cnProcBufRes, NR_LDPC_SIZE_CN_PROC_BUF); + nrLDPC_writeFile("cnProcBufRes.txt", p_procBuf->cnProcBufRes, NR_LDPC_SIZE_CN_PROC_BUF); break; } case nrLDPC_buffers_BN_PROC: { - nrLDPC_writeFile("bnProcBuf.txt", bnProcBuf, NR_LDPC_SIZE_BN_PROC_BUF); + nrLDPC_writeFile("bnProcBuf.txt", p_procBuf->bnProcBuf, NR_LDPC_SIZE_BN_PROC_BUF); break; } case nrLDPC_buffers_BN_PROC_RES: { - nrLDPC_writeFile("bnProcBufRes.txt", bnProcBufRes, NR_LDPC_SIZE_BN_PROC_BUF); + nrLDPC_writeFile("bnProcBufRes.txt", p_procBuf->bnProcBufRes, NR_LDPC_SIZE_BN_PROC_BUF); break; } case nrLDPC_buffers_LLR_RES: { - nrLDPC_writeFile("llrRes.txt", llrRes, NR_LDPC_MAX_NUM_LLR); + nrLDPC_writeFile("llrRes.txt", p_procBuf->llrRes, NR_LDPC_MAX_NUM_LLR); break; } } diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_types.h b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_types.h index 3c5128d1a1..ae32f6ffb6 100644 --- a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_types.h +++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_types.h @@ -88,4 +88,16 @@ typedef struct nrLDPC_time_stats { time_stats_t total; /**< Statistics for total processing time */ } t_nrLDPC_time_stats; +/** + Structure containing the processing buffers + */ +typedef struct nrLDPC_procBuf { + int8_t* cnProcBuf; /**< CN processing buffer */ + int8_t* cnProcBufRes; /**< Buffer for CN processing results */ + int8_t* bnProcBuf; /**< BN processing buffer */ + int8_t* bnProcBufRes; /**< Buffer for BN processing results */ + int8_t* llrRes; /**< Buffer for LLR results */ + int8_t* llrProcBuf; /**< LLR processing buffer */ +} t_nrLDPC_procBuf; + #endif diff --git a/openair1/PHY/INIT/nr_init_ue.c b/openair1/PHY/INIT/nr_init_ue.c index 1e8f2bc990..51d881b13e 100644 --- a/openair1/PHY/INIT/nr_init_ue.c +++ b/openair1/PHY/INIT/nr_init_ue.c @@ -942,9 +942,7 @@ void init_nr_ue_transport(PHY_VARS_NR_UE *ue,int abstraction_flag) { void phy_init_nr_top(PHY_VARS_NR_UE *ue) { NR_DL_FRAME_PARMS *frame_parms = &ue->frame_parms; - NR_UE_DLSCH_t *dlsch0 = ue->dlsch[0][0][0]; - dlsch0 =(NR_UE_DLSCH_t *)malloc16(sizeof(NR_UE_DLSCH_t)); - + crcTableInit(); init_dfts(); diff --git a/openair1/PHY/NR_TRANSPORT/nr_transport_common_proto.h b/openair1/PHY/NR_TRANSPORT/nr_transport_common_proto.h index 3c318874ac..b075da4e97 100644 --- a/openair1/PHY/NR_TRANSPORT/nr_transport_common_proto.h +++ b/openair1/PHY/NR_TRANSPORT/nr_transport_common_proto.h @@ -1,3 +1,4 @@ + /* * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more * contributor license agreements. See the NOTICE file distributed with @@ -33,7 +34,7 @@ #ifndef __NR_TRANSPORT_COMMON_PROTO__H__ #define __NR_TRANSPORT_COMMON_PROTO__H__ -#define MAX_NUM_NR_DLSCH_SEGMENTS 32 +#define MAX_NUM_NR_DLSCH_SEGMENTS 16 #define MAX_NUM_NR_ULSCH_SEGMENTS MAX_NUM_NR_DLSCH_SEGMENTS #define MAX_NR_DLSCH_PAYLOAD_BYTES (MAX_NUM_NR_DLSCH_SEGMENTS*1056) diff --git a/openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_decoding.c b/openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_decoding.c index 428dfc9e99..02ea89eb55 100644 --- a/openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_decoding.c +++ b/openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_decoding.c @@ -45,8 +45,6 @@ #define OAI_LDPC_MAX_NUM_LLR 27000//26112 // NR_LDPC_NCOL_BG1*NR_LDPC_ZMAX -static int8_t llrProcBuf[OAI_LDPC_MAX_NUM_LLR] __attribute__ ((aligned(32))); - static uint64_t nb_total_decod =0; static uint64_t nb_error_decod =0; @@ -75,12 +73,19 @@ void free_nr_ue_dlsch(NR_UE_DLSCH_t *dlsch) free16(dlsch->harq_processes[i]->d[r],(3*8448)*sizeof(short)); dlsch->harq_processes[i]->d[r] = NULL; } + + for (r=0; r<(MAX_NUM_NR_DLSCH_SEGMENTS); r++) { + if (dlsch->harq_processes[i]->p_nrLDPC_procBuf[r]){ + nrLDPC_free_mem(dlsch->harq_processes[i]->p_nrLDPC_procBuf[r]); + dlsch->harq_processes[i]->p_nrLDPC_procBuf[r] = NULL; + } + } free16(dlsch->harq_processes[i],sizeof(NR_DL_UE_HARQ_t)); dlsch->harq_processes[i] = NULL; } } - + free16(dlsch,sizeof(NR_UE_DLSCH_t)); dlsch = NULL; } @@ -120,7 +125,7 @@ NR_UE_DLSCH_t *new_nr_ue_dlsch(uint8_t Kmimo,uint8_t Mdlharq,uint32_t Nsoft,uint dlsch->Mdlharq = Mdlharq; dlsch->Nsoft = Nsoft; dlsch->max_ldpc_iterations = max_ldpc_iterations; - + for (i=0; iharq_processes[i] = (NR_DL_UE_HARQ_t *)malloc16(sizeof(NR_DL_UE_HARQ_t)); @@ -136,7 +141,8 @@ NR_UE_DLSCH_t *new_nr_ue_dlsch(uint8_t Kmimo,uint8_t Mdlharq,uint32_t Nsoft,uint exit_flag=3; if (abstraction_flag == 0) { - for (r=0; rharq_processes[i]->p_nrLDPC_procBuf[r] = nrLDPC_init_mem(); dlsch->harq_processes[i]->c[r] = (uint8_t*)malloc16(1056); if (dlsch->harq_processes[i]->c[r]) @@ -215,10 +221,13 @@ uint32_t nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue, //short dummy_w[MAX_NUM_DLSCH_SEGMENTS][3*(8448+64)]; uint32_t r,r_offset=0,Kr=8424,Kr_bytes,K_bytes_F,err_flag=0; uint8_t crc_type; + int8_t llrProcBuf[OAI_LDPC_MAX_NUM_LLR] __attribute__ ((aligned(32))); t_nrLDPC_dec_params decParams; t_nrLDPC_dec_params* p_decParams = &decParams; t_nrLDPC_time_stats procTime; t_nrLDPC_time_stats* p_procTime =&procTime ; + t_nrLDPC_procBuf** p_nrLDPC_procBuf = harq_process->p_nrLDPC_procBuf; + int16_t z [68*384]; int8_t l [68*384]; //__m128i l; @@ -506,7 +515,8 @@ uint32_t nr_dlsch_decoding(PHY_VARS_NR_UE *phy_vars_ue, no_iteration_ldpc = nrLDPC_decoder(p_decParams, (int8_t*)&pl[0], llrProcBuf, - p_procTime); + p_nrLDPC_procBuf[r], + p_procTime); if (check_crc(llrProcBuf,harq_process->B,harq_process->F,crc_type)) { printf("CRC OK\n"); @@ -691,6 +701,9 @@ uint32_t nr_dlsch_decoding_mthread(PHY_VARS_NR_UE *phy_vars_ue, t_nrLDPC_dec_params* p_decParams = &decParams; t_nrLDPC_time_stats procTime; t_nrLDPC_time_stats* p_procTime =&procTime ; + int8_t llrProcBuf[OAI_LDPC_MAX_NUM_LLR] __attribute__ ((aligned(32))); + t_nrLDPC_procBuf* p_nrLDPC_procBuf = harq_process->p_nrLDPC_procBuf[0]; + int16_t z [68*384]; int8_t l [68*384]; //__m128i l; @@ -786,7 +799,7 @@ uint32_t nr_dlsch_decoding_mthread(PHY_VARS_NR_UE *phy_vars_ue, kb = harq_process->K/harq_process->Z; if ( kb==22){ p_decParams->BG = 1; - p_decParams->R = 89; + p_decParams->R = 13; kc = 68; } else{ @@ -825,7 +838,7 @@ uint32_t nr_dlsch_decoding_mthread(PHY_VARS_NR_UE *phy_vars_ue, return((1+dlsch->max_ldpc_iterations)); } #ifdef DEBUG_DLSCH_DECODING - printf("Segmentation: C %d, Cminus %d, Kminus %d, Kplus %d\n",harq_process->C,harq_process->Cminus,harq_process->Kminus,harq_process->Kplus); + printf("Segmentation: C %d, K %d\n",harq_process->C,harq_process->K); #endif opp_enabled=1; @@ -955,7 +968,9 @@ if (harq_process->C>1) { // wakeup worker if more than 1 segment Cby2 = 1; } - for (r=0; rK; Kr_bytes = Kr>>3; @@ -1007,8 +1022,13 @@ if (harq_process->C>1) { // wakeup worker if more than 1 segment stop_meas(dlsch_rate_unmatching_stats); #endif } - r_offset += E; + //r_offset += E; //printf("main thread r_offset %d\n",r_offset); + +#ifdef DEBUG_DLSCH_DECODING + for (int i =0; i<16; i++) + printf("rx output ratematching w[%d]= %d r_offset %d\n", i,harq_process->w[r][i], r_offset); +#endif /* printf("Subblock deinterleaving, d %p w %p\n", @@ -1022,6 +1042,11 @@ if (harq_process->C>1) { // wakeup worker if more than 1 segment harq_process->Qm, harq_process->d[r], harq_process->w[r]); +#ifdef DEBUG_DLSCH_DECODING + for (int i =0; i<16; i++) + printf("rx output interleaving d[%d]= %d r_offset %d\n", i,harq_process->d[r][i], r_offset); +#endif + #if UE_TIMING_TRACE stop_meas(dlsch_deinterleaving_stats); #endif @@ -1064,6 +1089,10 @@ if (harq_process->C>1) { // wakeup worker if more than 1 segment start_meas(dlsch_turbo_decoding_stats); #endif LOG_D(PHY,"mthread AbsSubframe %d.%d Start turbo segment %d/%d \n",frame%1024,nr_tti_rx,r,harq_process->C-1); + + for (int cnt =0; cnt < (kc-2)*p_decParams->Z; cnt++){ + inv_d[cnt] = (1)*harq_process->d[r][cnt]; + } memset(pv,0,2*p_decParams->Z*sizeof(int16_t)); //memset(pl,0,2*p_decParams->Z*sizeof(int8_t)); @@ -1090,6 +1119,7 @@ if (harq_process->C>1) { // wakeup worker if more than 1 segment no_iteration_ldpc = nrLDPC_decoder(p_decParams, (int8_t*)&pl[0], llrProcBuf, + p_nrLDPC_procBuf, p_procTime); nb_total_decod++; @@ -1100,6 +1130,16 @@ if (harq_process->C>1) { // wakeup worker if more than 1 segment else { ret=2; } + + if (check_crc(llrProcBuf,harq_process->B,harq_process->F,crc_type)) { + printf("CRC OK\n"); + ret = 2; + } + else { + printf("CRC NOK\n"); + ret = 1+dlsch->max_ldpc_iterations; + } + //if (!nb_total_decod%10000){ printf("Error number of iteration LPDC %d %ld/%ld \n", no_iteration_ldpc, nb_error_decod,nb_total_decod);fflush(stdout); //} @@ -1130,7 +1170,10 @@ if (harq_process->C>1) { // wakeup worker if more than 1 segment //printf("output channel decoder %d %d %d %d %d \n", harq_process->c[r][0], harq_process->c[r][1], harq_process->c[r][2],harq_process->c[r][3], harq_process->c[r][4]); //printf("output decoder %d %d %d %d %d \n", harq_process->c[r][0], harq_process->c[r][1], harq_process->c[r][2],harq_process->c[r][3], harq_process->c[r][4]); - +#ifdef DEBUG_DLSCH_DECODING + for (int k=0;k<32;k++) + printf("output decoder [%d] = 0x%02x \n", k, harq_process->c[r][k]); +#endif #if UE_TIMING_TRACE stop_meas(dlsch_turbo_decoding_stats); @@ -1142,7 +1185,7 @@ if (harq_process->C>1) { // wakeup worker if more than 1 segment LOG_D(PHY,"AbsSubframe %d.%d CRC failed, segment %d/%d \n",frame%1024,nr_tti_rx,r,harq_process->C-1); err_flag = 1; } - } + //} //loop r int32_t frame_rx_prev = frame; int32_t tti_rx_prev = nr_tti_rx - 1; @@ -1273,6 +1316,8 @@ void *nr_dlsch_decoding_2thread0(void *arg) t_nrLDPC_dec_params* p_decParams = &decParams; t_nrLDPC_time_stats procTime; t_nrLDPC_time_stats* p_procTime =&procTime ; + int8_t llrProcBuf[OAI_LDPC_MAX_NUM_LLR] __attribute__ ((aligned(32))); + t_nrLDPC_procBuf* p_nrLDPC_procBuf; int16_t z [68*384]; int8_t l [68*384]; //__m128i l; @@ -1365,6 +1410,7 @@ void *nr_dlsch_decoding_2thread0(void *arg) NR_DL_UE_HARQ_t *harq_process = dlsch->harq_processes[harq_pid]; short *dlsch_llr = phy_vars_ue->pdsch_vars[phy_vars_ue->current_thread_id[subframe]][eNB_id]->llr[0]; //printf("2thread0 llr flag %d tdp flag %d\n",llr8_flag1, tdp->llr8_flag); + p_nrLDPC_procBuf = harq_process->p_nrLDPC_procBuf[1]; /* if (nb_rb > frame_parms->N_RB_DL) { @@ -1410,7 +1456,7 @@ void *nr_dlsch_decoding_2thread0(void *arg) kb = harq_process->K/harq_process->Z; if ( kb==22){ p_decParams->BG = 1; - p_decParams->R = 89; + p_decParams->R = 13; kc = 68; } else{ @@ -1523,7 +1569,7 @@ void *nr_dlsch_decoding_2thread0(void *arg) stop_meas(dlsch_rate_unmatching_stats); #endif } - r_offset += E; + //r_offset += E; //for (int i =0; i<16; i++) // printf("rx output ratematching w[%d]= %d r_offset %d\n", i,harq_process->w[r][i], r_offset); @@ -1606,6 +1652,7 @@ void *nr_dlsch_decoding_2thread0(void *arg) no_iteration_ldpc = nrLDPC_decoder(p_decParams, (int8_t*)&pl[0], llrProcBuf, + p_nrLDPC_procBuf, p_procTime); if (no_iteration_ldpc > 10) @@ -1633,6 +1680,10 @@ void *nr_dlsch_decoding_2thread0(void *arg) } printf(" \n");*/ +#ifdef DEBUG_DLSCH_DECODING + for (int k=0;k<2;k++) + printf("segment 1 output decoder [%d] = 0x%02x \n", k, harq_process->c[r][k]); +#endif #if UE_TIMING_TRACE stop_meas(dlsch_turbo_decoding_stats); @@ -1778,6 +1829,8 @@ void *nr_dlsch_decoding_2thread1(void *arg) t_nrLDPC_dec_params* p_decParams = &decParams; t_nrLDPC_time_stats procTime; t_nrLDPC_time_stats* p_procTime =&procTime ; + t_nrLDPC_procBuf* p_nrLDPC_procBuf; + int8_t llrProcBuf[OAI_LDPC_MAX_NUM_LLR] __attribute__ ((aligned(32))); int16_t z [68*384]; int8_t l [68*384]; //__m128i l; @@ -1871,6 +1924,7 @@ void *nr_dlsch_decoding_2thread1(void *arg) short *dlsch_llr = phy_vars_ue->pdsch_vars[phy_vars_ue->current_thread_id[subframe]][eNB_id]->llr[0]; //printf("2thread0 llr flag %d tdp flag %d\n",llr8_flag1, tdp->llr8_flag); //printf("2thread1 nr_tti_tx %d subframe %d SF thread id %d r_offset %d\n", proc->nr_tti_rx, subframe, phy_vars_ue->current_thread_id[subframe], r_offset); + p_nrLDPC_procBuf = harq_process->p_nrLDPC_procBuf[2]; /* if (nb_rb > frame_parms->N_RB_DL) { @@ -2032,7 +2086,7 @@ void *nr_dlsch_decoding_2thread1(void *arg) stop_meas(dlsch_rate_unmatching_stats); #endif } - r_offset += E; + //r_offset += E; /* printf("Subblock deinterleaving, d %p w %p\n", @@ -2110,6 +2164,7 @@ void *nr_dlsch_decoding_2thread1(void *arg) no_iteration_ldpc = nrLDPC_decoder(p_decParams, (int8_t*)&pl[0], llrProcBuf, + p_nrLDPC_procBuf, p_procTime); if (no_iteration_ldpc > 10) diff --git a/openair1/PHY/NR_UE_TRANSPORT/nr_transport_ue.h b/openair1/PHY/NR_UE_TRANSPORT/nr_transport_ue.h index f89816c782..b41b23dd32 100644 --- a/openair1/PHY/NR_UE_TRANSPORT/nr_transport_ue.h +++ b/openair1/PHY/NR_UE_TRANSPORT/nr_transport_ue.h @@ -34,7 +34,7 @@ #include #include "PHY/impl_defs_top.h" - +#include "PHY/CODING/nrLDPC_decoder/nrLDPC_types.h" //#include "PHY/defs_nr_UE.h" #include "../NR_TRANSPORT/nr_transport_common_proto.h" @@ -267,6 +267,8 @@ typedef struct { double w_abs[MAX_NUM_NR_DLSCH_SEGMENTS][3*8448]; /// soft bits for each received segment ("d"-sequence)(for definition see 36-212 V8.6 2009-03, p.15) int16_t *d[MAX_NUM_NR_DLSCH_SEGMENTS]; + /// LDPC processing buffers + t_nrLDPC_procBuf* p_nrLDPC_procBuf[MAX_NUM_DLSCH_SEGMENTS]; /// Number of code segments uint32_t C; /// Number of bits in code segments @@ -353,9 +355,7 @@ typedef struct { /// Maximum number of LDPC iterations uint8_t max_ldpc_iterations; /// number of iterations used in last turbo decoding - uint8_t last_iteration_cnt; - - + uint8_t last_iteration_cnt; } NR_UE_DLSCH_t; typedef enum {format0_0,