Commit 11441023 authored by Laurent THOMAS's avatar Laurent THOMAS

fix polar race condition

parent ae803b53
...@@ -86,6 +86,7 @@ check_supported_distribution() { ...@@ -86,6 +86,7 @@ check_supported_distribution() {
"ubuntu20.04") return 0 ;; "ubuntu20.04") return 0 ;;
"ubuntu20.10") return 0 ;; "ubuntu20.10") return 0 ;;
"ubuntu21.04") return 0 ;; "ubuntu21.04") return 0 ;;
"ubuntu21.10") return 0 ;;
esac esac
return 1 return 1
} }
......
...@@ -268,7 +268,7 @@ int8_t polar_decoder(double *input, ...@@ -268,7 +268,7 @@ int8_t polar_decoder(double *input,
if (decoderIterationCheck==0) { if (decoderIterationCheck==0) {
//perror("[SCL polar decoder] All list entries have failed the CRC checks."); //perror("[SCL polar decoder] All list entries have failed the CRC checks.");
return(-1); polarReturn(-1);
} }
nonFrozenBit++; nonFrozenBit++;
...@@ -301,7 +301,8 @@ int8_t polar_decoder(double *input, ...@@ -301,7 +301,8 @@ int8_t polar_decoder(double *input,
* Return bits. * Return bits.
*/ */
nr_byte2bit_uint8_32(polarParams->nr_polar_A, polarParams->payloadBits, out); nr_byte2bit_uint8_32(polarParams->nr_polar_A, polarParams->payloadBits, out);
return(0);
polarReturn 0;
} }
int8_t polar_decoder_dci(double *input, int8_t polar_decoder_dci(double *input,
...@@ -532,7 +533,7 @@ int8_t polar_decoder_dci(double *input, ...@@ -532,7 +533,7 @@ int8_t polar_decoder_dci(double *input,
if (decoderIterationCheck==0) { if (decoderIterationCheck==0) {
//perror("[SCL polar decoder] All list entries have failed the CRC checks."); //perror("[SCL polar decoder] All list entries have failed the CRC checks.");
return(-1); polarReturn -1;
} }
nonFrozenBit++; nonFrozenBit++;
...@@ -565,7 +566,8 @@ int8_t polar_decoder_dci(double *input, ...@@ -565,7 +566,8 @@ int8_t polar_decoder_dci(double *input,
* Return bits. * Return bits.
*/ */
nr_byte2bit_uint8_32(polarParams->nr_polar_A, polarParams->payloadBits, out); nr_byte2bit_uint8_32(polarParams->nr_polar_A, polarParams->payloadBits, out);
return(0);
polarReturn 0;
} }
void init_polar_deinterleaver_table(t_nrPolar_params *polarParams) { void init_polar_deinterleaver_table(t_nrPolar_params *polarParams) {
...@@ -705,5 +707,6 @@ uint32_t polar_decoder_int16(int16_t *input, ...@@ -705,5 +707,6 @@ uint32_t polar_decoder_int16(int16_t *input,
rxcrc,polarParams->payloadBits); rxcrc,polarParams->payloadBits);
#endif #endif
out[0]=Ar; out[0]=Ar;
return(crc^rxcrc);
polarReturn crc^rxcrc;
} }
...@@ -81,6 +81,7 @@ struct nrPolar_params { ...@@ -81,6 +81,7 @@ struct nrPolar_params {
//messageType: 0=PBCH, 1=DCI, -1=UCI //messageType: 0=PBCH, 1=DCI, -1=UCI
struct nrPolar_params *nextPtr __attribute__((aligned(16))); struct nrPolar_params *nextPtr __attribute__((aligned(16)));
bool busy;
uint32_t idx; uint32_t idx;
uint8_t n_max; uint8_t n_max;
uint8_t i_il; uint8_t i_il;
...@@ -344,4 +345,11 @@ static inline void nr_polar_deinterleaver(uint8_t *input, ...@@ -344,4 +345,11 @@ static inline void nr_polar_deinterleaver(uint8_t *input,
for (int i=0; i<size; i++) output[pattern[i]]=input[i]; for (int i=0; i<size; i++) output[pattern[i]]=input[i];
} }
void delete_decoder_tree(t_nrPolar_params *); void delete_decoder_tree(t_nrPolar_params *);
#define polarReturn \
pthread_mutex_lock(&PolarListMutex); \
currentPtr->busy=false; \
pthread_mutex_unlock(&PolarListMutex); \
return
#endif #endif
...@@ -60,10 +60,10 @@ void polar_encoder(uint32_t *in, ...@@ -60,10 +60,10 @@ void polar_encoder(uint32_t *in,
*/ */
//Calculate CRC. //Calculate CRC.
nr_matrix_multiplication_uint8_1D_uint8_2D(polarParams->nr_polar_A, nr_matrix_multiplication_uint8_1D_uint8_2D(polarParams->nr_polar_A,
polarParams->crc_generator_matrix, polarParams->crc_generator_matrix,
polarParams->nr_polar_crc, polarParams->nr_polar_crc,
polarParams->payloadBits, polarParams->payloadBits,
polarParams->crcParityBits); polarParams->crcParityBits);
for (uint8_t i = 0; i < polarParams->crcParityBits; i++) for (uint8_t i = 0; i < polarParams->crcParityBits; i++)
polarParams->nr_polar_crc[i] = (polarParams->nr_polar_crc[i] % 2); polarParams->nr_polar_crc[i] = (polarParams->nr_polar_crc[i] % 2);
...@@ -153,6 +153,9 @@ void polar_encoder(uint32_t *in, ...@@ -153,6 +153,9 @@ void polar_encoder(uint32_t *in,
#endif #endif
nr_byte2bit_uint8_32(polarParams->nr_polar_E, polarParams->encoderLength, out); nr_byte2bit_uint8_32(polarParams->nr_polar_E, polarParams->encoderLength, out);
polarReturn;
} }
void polar_encoder_dci(uint32_t *in, void polar_encoder_dci(uint32_t *in,
...@@ -256,6 +259,7 @@ void polar_encoder_dci(uint32_t *in, ...@@ -256,6 +259,7 @@ void polar_encoder_dci(uint32_t *in,
printf("\n[polar_encoder_dci] out: "); printf("\n[polar_encoder_dci] out: ");
for (int i = 0; i < outputInd; i++) printf("[%d]->0x%08x\t", i, out[i]); for (int i = 0; i < outputInd; i++) printf("[%d]->0x%08x\t", i, out[i]);
#endif #endif
polarReturn;
} }
static inline void polar_rate_matching(const t_nrPolar_params *polarParams,void *in,void *out) __attribute__((always_inline)); static inline void polar_rate_matching(const t_nrPolar_params *polarParams,void *in,void *out) __attribute__((always_inline));
...@@ -698,4 +702,7 @@ void polar_encoder_fast(uint64_t *A, ...@@ -698,4 +702,7 @@ void polar_encoder_fast(uint64_t *A,
} }
memset((void*)out,0,polarParams->encoderLength>>3); memset((void*)out,0,polarParams->encoderLength>>3);
polar_rate_matching(polarParams,(void *)D, out); polar_rate_matching(polarParams,(void *)D, out);
polarReturn;
} }
...@@ -100,10 +100,11 @@ t_nrPolar_params * nr_polar_params(int8_t messageType, ...@@ -100,10 +100,11 @@ t_nrPolar_params * nr_polar_params(int8_t messageType,
while (currentPtr != NULL) { while (currentPtr != NULL) {
//printf("currentPtr->idx %d, (%d,%d)\n",currentPtr->idx,currentPtr->payloadBits,currentPtr->encoderLength); //printf("currentPtr->idx %d, (%d,%d)\n",currentPtr->idx,currentPtr->payloadBits,currentPtr->encoderLength);
//LOG_D(PHY,"Looking for index %d\n",(messageType * messageLength * aggregation_prime)); //LOG_D(PHY,"Looking for index %d\n",(messageType * messageLength * aggregation_prime));
if (currentPtr->idx == PolarKey ) { if (currentPtr->busy == false && currentPtr->idx == PolarKey ) {
currentPtr->busy=true;
pthread_mutex_unlock(&PolarListMutex);
if (decoder_flag && !currentPtr->tree.root) if (decoder_flag && !currentPtr->tree.root)
build_decoder_tree(currentPtr); build_decoder_tree(currentPtr);
pthread_mutex_unlock(&PolarListMutex);
return currentPtr ; return currentPtr ;
} }
else else
...@@ -113,143 +114,142 @@ t_nrPolar_params * nr_polar_params(int8_t messageType, ...@@ -113,143 +114,142 @@ t_nrPolar_params * nr_polar_params(int8_t messageType,
// printf("currentPtr %p (polarParams %p)\n",currentPtr,polarParams); // printf("currentPtr %p (polarParams %p)\n",currentPtr,polarParams);
//Else, initialize and add node to the end of the linked list. //Else, initialize and add node to the end of the linked list.
t_nrPolar_params *newPolarInitNode = calloc(sizeof(t_nrPolar_params),1); t_nrPolar_params *newPolarInitNode = calloc(sizeof(t_nrPolar_params),1);
newPolarInitNode->busy=true;
if (newPolarInitNode != NULL) { pthread_mutex_unlock(&PolarListMutex);
// LOG_D(PHY,"Setting new polarParams index %d, messageType %d, messageLength %d, aggregation_prime %d\n",(messageType * messageLength * aggregation_prime),messageType,messageLength,aggregation_prime);
newPolarInitNode->idx = PolarKey;
newPolarInitNode->nextPtr = NULL;
//printf("newPolarInitNode->idx %d, (%d,%d,%d:%d)\n",newPolarInitNode->idx,messageType,messageLength,aggregation_prime,aggregation_level);
if (messageType == 0) { //PBCH AssertFatal(newPolarInitNode != NULL, "[nr_polar_init] New t_nrPolar_params * could not be created");
newPolarInitNode->n_max = NR_POLAR_PBCH_N_MAX;
newPolarInitNode->i_il = NR_POLAR_PBCH_I_IL; // LOG_D(PHY,"Setting new polarParams index %d, messageType %d, messageLength %d, aggregation_prime %d\n",(messageType * messageLength * aggregation_prime),messageType,messageLength,aggregation_prime);
newPolarInitNode->i_seg = NR_POLAR_PBCH_I_SEG; newPolarInitNode->idx = PolarKey;
newPolarInitNode->n_pc = NR_POLAR_PBCH_N_PC; newPolarInitNode->nextPtr = NULL;
newPolarInitNode->n_pc_wm = NR_POLAR_PBCH_N_PC_WM; //printf("newPolarInitNode->idx %d, (%d,%d,%d:%d)\n",newPolarInitNode->idx,messageType,messageLength,aggregation_prime,aggregation_level);
newPolarInitNode->i_bil = NR_POLAR_PBCH_I_BIL;
newPolarInitNode->crcParityBits = NR_POLAR_PBCH_CRC_PARITY_BITS; if (messageType == 0) { //PBCH
newPolarInitNode->payloadBits = NR_POLAR_PBCH_PAYLOAD_BITS; newPolarInitNode->n_max = NR_POLAR_PBCH_N_MAX;
newPolarInitNode->encoderLength = NR_POLAR_PBCH_E; newPolarInitNode->i_il = NR_POLAR_PBCH_I_IL;
newPolarInitNode->crcCorrectionBits = NR_POLAR_PBCH_CRC_ERROR_CORRECTION_BITS; newPolarInitNode->i_seg = NR_POLAR_PBCH_I_SEG;
newPolarInitNode->crc_generator_matrix = crc24c_generator_matrix(newPolarInitNode->payloadBits);//G_P newPolarInitNode->n_pc = NR_POLAR_PBCH_N_PC;
//printf("Initializing polar parameters for PBCH (K %d, E %d)\n",newPolarInitNode->payloadBits,newPolarInitNode->encoderLength); newPolarInitNode->n_pc_wm = NR_POLAR_PBCH_N_PC_WM;
} else if (messageType == 1) { //DCI newPolarInitNode->i_bil = NR_POLAR_PBCH_I_BIL;
newPolarInitNode->n_max = NR_POLAR_DCI_N_MAX; newPolarInitNode->crcParityBits = NR_POLAR_PBCH_CRC_PARITY_BITS;
newPolarInitNode->i_il = NR_POLAR_DCI_I_IL; newPolarInitNode->payloadBits = NR_POLAR_PBCH_PAYLOAD_BITS;
newPolarInitNode->i_seg = NR_POLAR_DCI_I_SEG; newPolarInitNode->encoderLength = NR_POLAR_PBCH_E;
newPolarInitNode->n_pc = NR_POLAR_DCI_N_PC; newPolarInitNode->crcCorrectionBits = NR_POLAR_PBCH_CRC_ERROR_CORRECTION_BITS;
newPolarInitNode->n_pc_wm = NR_POLAR_DCI_N_PC_WM; newPolarInitNode->crc_generator_matrix = crc24c_generator_matrix(newPolarInitNode->payloadBits);//G_P
newPolarInitNode->i_bil = NR_POLAR_DCI_I_BIL; //printf("Initializing polar parameters for PBCH (K %d, E %d)\n",newPolarInitNode->payloadBits,newPolarInitNode->encoderLength);
newPolarInitNode->crcParityBits = NR_POLAR_DCI_CRC_PARITY_BITS; } else if (messageType == 1) { //DCI
newPolarInitNode->payloadBits = messageLength; newPolarInitNode->n_max = NR_POLAR_DCI_N_MAX;
newPolarInitNode->encoderLength = aggregation_level*108; newPolarInitNode->i_il = NR_POLAR_DCI_I_IL;
newPolarInitNode->crcCorrectionBits = NR_POLAR_DCI_CRC_ERROR_CORRECTION_BITS; newPolarInitNode->i_seg = NR_POLAR_DCI_I_SEG;
newPolarInitNode->crc_generator_matrix=crc24c_generator_matrix(newPolarInitNode->payloadBits+newPolarInitNode->crcParityBits);//G_P newPolarInitNode->n_pc = NR_POLAR_DCI_N_PC;
//printf("Initializing polar parameters for DCI (K %d, E %d, L %d)\n",newPolarInitNode->payloadBits,newPolarInitNode->encoderLength,aggregation_level); newPolarInitNode->n_pc_wm = NR_POLAR_DCI_N_PC_WM;
} else if (messageType == 2) { //UCI PUCCH2 newPolarInitNode->i_bil = NR_POLAR_DCI_I_BIL;
AssertFatal(aggregation_level>2,"Aggregation level (%d) for PUCCH 2 encoding is NPRB and should be > 2\n",aggregation_level); newPolarInitNode->crcParityBits = NR_POLAR_DCI_CRC_PARITY_BITS;
AssertFatal(messageLength>11,"Message length %d is too short for polar encoding of UCI\n",messageLength); newPolarInitNode->payloadBits = messageLength;
newPolarInitNode->n_max = NR_POLAR_PUCCH_N_MAX; newPolarInitNode->encoderLength = aggregation_level*108;
newPolarInitNode->i_il = NR_POLAR_PUCCH_I_IL; newPolarInitNode->crcCorrectionBits = NR_POLAR_DCI_CRC_ERROR_CORRECTION_BITS;
newPolarInitNode->encoderLength = aggregation_level * 16; newPolarInitNode->crc_generator_matrix=crc24c_generator_matrix(newPolarInitNode->payloadBits+newPolarInitNode->crcParityBits);//G_P
//printf("Initializing polar parameters for DCI (K %d, E %d, L %d)\n",newPolarInitNode->payloadBits,newPolarInitNode->encoderLength,aggregation_level);
} else if (messageType == 2) { //UCI PUCCH2
AssertFatal(aggregation_level>2,"Aggregation level (%d) for PUCCH 2 encoding is NPRB and should be > 2\n",aggregation_level);
AssertFatal(messageLength>11,"Message length %d is too short for polar encoding of UCI\n",messageLength);
newPolarInitNode->n_max = NR_POLAR_PUCCH_N_MAX;
newPolarInitNode->i_il = NR_POLAR_PUCCH_I_IL;
newPolarInitNode->encoderLength = aggregation_level * 16;
newPolarInitNode->i_seg = 0; newPolarInitNode->i_seg = 0;
if ((messageLength >= 360 && newPolarInitNode->encoderLength >= 1088)|| if ((messageLength >= 360 && newPolarInitNode->encoderLength >= 1088)||
(messageLength >= 1013)) newPolarInitNode->i_seg = 1; (messageLength >= 1013)) newPolarInitNode->i_seg = 1;
newPolarInitNode->crcParityBits = 11; newPolarInitNode->crcParityBits = 11;
newPolarInitNode->n_pc = 0; newPolarInitNode->n_pc = 0;
newPolarInitNode->n_pc_wm = 0; newPolarInitNode->n_pc_wm = 0;
if (messageLength < 20) { if (messageLength < 20) {
newPolarInitNode->crcParityBits = 6; newPolarInitNode->crcParityBits = 6;
newPolarInitNode->n_pc = 3; newPolarInitNode->n_pc = 3;
if ((newPolarInitNode->encoderLength - messageLength - 6 + 3) < 193) newPolarInitNode->n_pc_wm = 1; if ((newPolarInitNode->encoderLength - messageLength - 6 + 3) < 193) newPolarInitNode->n_pc_wm = 1;
} }
newPolarInitNode->i_bil = NR_POLAR_PUCCH_I_BIL; newPolarInitNode->i_bil = NR_POLAR_PUCCH_I_BIL;
newPolarInitNode->payloadBits = messageLength; newPolarInitNode->payloadBits = messageLength;
newPolarInitNode->crcCorrectionBits = NR_POLAR_PUCCH_CRC_ERROR_CORRECTION_BITS; newPolarInitNode->crcCorrectionBits = NR_POLAR_PUCCH_CRC_ERROR_CORRECTION_BITS;
//newPolarInitNode->crc_generator_matrix=crc24c_generator_matrix(newPolarInitNode->payloadBits+newPolarInitNode->crcParityBits);//G_P //newPolarInitNode->crc_generator_matrix=crc24c_generator_matrix(newPolarInitNode->payloadBits+newPolarInitNode->crcParityBits);//G_P
//LOG_D(PHY,"New polar node, encoderLength %d, aggregation_level %d\n",newPolarInitNode->encoderLength,aggregation_level); //LOG_D(PHY,"New polar node, encoderLength %d, aggregation_level %d\n",newPolarInitNode->encoderLength,aggregation_level);
} else { } else {
AssertFatal(1 == 0, "[nr_polar_init] Incorrect Message Type(%d)", messageType); AssertFatal(1 == 0, "[nr_polar_init] Incorrect Message Type(%d)", messageType);
} }
newPolarInitNode->K = newPolarInitNode->payloadBits + newPolarInitNode->crcParityBits; // Number of bits to encode. newPolarInitNode->K = newPolarInitNode->payloadBits + newPolarInitNode->crcParityBits; // Number of bits to encode.
newPolarInitNode->N = nr_polar_output_length(newPolarInitNode->K, newPolarInitNode->N = nr_polar_output_length(newPolarInitNode->K,
newPolarInitNode->encoderLength, newPolarInitNode->encoderLength,
newPolarInitNode->n_max); newPolarInitNode->n_max);
newPolarInitNode->n = log2(newPolarInitNode->N); newPolarInitNode->n = log2(newPolarInitNode->N);
newPolarInitNode->G_N = nr_polar_kronecker_power_matrices(newPolarInitNode->n); newPolarInitNode->G_N = nr_polar_kronecker_power_matrices(newPolarInitNode->n);
//polar_encoder vectors: //polar_encoder vectors:
newPolarInitNode->nr_polar_crc = malloc(sizeof(uint8_t) * newPolarInitNode->crcParityBits); newPolarInitNode->nr_polar_crc = malloc(sizeof(uint8_t) * newPolarInitNode->crcParityBits);
newPolarInitNode->nr_polar_aPrime = malloc(sizeof(uint8_t) * ((ceil((newPolarInitNode->payloadBits)/32.0)*4)+3)); newPolarInitNode->nr_polar_aPrime = malloc(sizeof(uint8_t) * ((ceil((newPolarInitNode->payloadBits)/32.0)*4)+3));
newPolarInitNode->nr_polar_APrime = malloc(sizeof(uint8_t) * newPolarInitNode->K); newPolarInitNode->nr_polar_APrime = malloc(sizeof(uint8_t) * newPolarInitNode->K);
newPolarInitNode->nr_polar_D = malloc(sizeof(uint8_t) * newPolarInitNode->N); newPolarInitNode->nr_polar_D = malloc(sizeof(uint8_t) * newPolarInitNode->N);
newPolarInitNode->nr_polar_E = malloc(sizeof(uint8_t) * newPolarInitNode->encoderLength); newPolarInitNode->nr_polar_E = malloc(sizeof(uint8_t) * newPolarInitNode->encoderLength);
//Polar Coding vectors //Polar Coding vectors
newPolarInitNode->nr_polar_U = malloc(sizeof(uint8_t) * newPolarInitNode->N); //Decoder: nr_polar_uHat newPolarInitNode->nr_polar_U = malloc(sizeof(uint8_t) * newPolarInitNode->N); //Decoder: nr_polar_uHat
newPolarInitNode->nr_polar_CPrime = malloc(sizeof(uint8_t) * newPolarInitNode->K); //Decoder: nr_polar_cHat newPolarInitNode->nr_polar_CPrime = malloc(sizeof(uint8_t) * newPolarInitNode->K); //Decoder: nr_polar_cHat
newPolarInitNode->nr_polar_B = malloc(sizeof(uint8_t) * newPolarInitNode->K); //Decoder: nr_polar_bHat newPolarInitNode->nr_polar_B = malloc(sizeof(uint8_t) * newPolarInitNode->K); //Decoder: nr_polar_bHat
newPolarInitNode->nr_polar_A = malloc(sizeof(uint8_t) * newPolarInitNode->payloadBits); //Decoder: nr_polar_aHat newPolarInitNode->nr_polar_A = malloc(sizeof(uint8_t) * newPolarInitNode->payloadBits); //Decoder: nr_polar_aHat
newPolarInitNode->Q_0_Nminus1 = nr_polar_sequence_pattern(newPolarInitNode->n); newPolarInitNode->Q_0_Nminus1 = nr_polar_sequence_pattern(newPolarInitNode->n);
newPolarInitNode->interleaving_pattern = malloc(sizeof(uint16_t) * newPolarInitNode->K); newPolarInitNode->interleaving_pattern = malloc(sizeof(uint16_t) * newPolarInitNode->K);
nr_polar_interleaving_pattern(newPolarInitNode->K, nr_polar_interleaving_pattern(newPolarInitNode->K,
newPolarInitNode->i_il, newPolarInitNode->i_il,
newPolarInitNode->interleaving_pattern); newPolarInitNode->interleaving_pattern);
newPolarInitNode->deinterleaving_pattern = malloc(sizeof(uint16_t) * newPolarInitNode->K); newPolarInitNode->deinterleaving_pattern = malloc(sizeof(uint16_t) * newPolarInitNode->K);
for (int i=0; i<newPolarInitNode->K; i++) for (int i=0; i<newPolarInitNode->K; i++)
newPolarInitNode->deinterleaving_pattern[newPolarInitNode->interleaving_pattern[i]] = i; newPolarInitNode->deinterleaving_pattern[newPolarInitNode->interleaving_pattern[i]] = i;
newPolarInitNode->rate_matching_pattern = malloc(sizeof(uint16_t) * newPolarInitNode->encoderLength); newPolarInitNode->rate_matching_pattern = malloc(sizeof(uint16_t) * newPolarInitNode->encoderLength);
uint16_t J[newPolarInitNode->N]; uint16_t J[newPolarInitNode->N];
nr_polar_rate_matching_pattern(newPolarInitNode->rate_matching_pattern, nr_polar_rate_matching_pattern(newPolarInitNode->rate_matching_pattern,
J, J,
nr_polar_subblock_interleaver_pattern, nr_polar_subblock_interleaver_pattern,
newPolarInitNode->K, newPolarInitNode->K,
newPolarInitNode->N, newPolarInitNode->N,
newPolarInitNode->encoderLength); newPolarInitNode->encoderLength);
newPolarInitNode->information_bit_pattern = malloc(sizeof(uint8_t) * newPolarInitNode->N); newPolarInitNode->information_bit_pattern = malloc(sizeof(uint8_t) * newPolarInitNode->N);
newPolarInitNode->Q_I_N = malloc(sizeof(int16_t) * (newPolarInitNode->K + newPolarInitNode->n_pc)); newPolarInitNode->Q_I_N = malloc(sizeof(int16_t) * (newPolarInitNode->K + newPolarInitNode->n_pc));
newPolarInitNode->Q_F_N = malloc( sizeof(int16_t) * (newPolarInitNode->N + 1)); // Last element shows the final array index assigned a value. newPolarInitNode->Q_F_N = malloc( sizeof(int16_t) * (newPolarInitNode->N + 1)); // Last element shows the final array index assigned a value.
newPolarInitNode->Q_PC_N = malloc( sizeof(int16_t) * (newPolarInitNode->n_pc)); newPolarInitNode->Q_PC_N = malloc( sizeof(int16_t) * (newPolarInitNode->n_pc));
for (int i = 0; i <= newPolarInitNode->N; i++) for (int i = 0; i <= newPolarInitNode->N; i++)
newPolarInitNode->Q_F_N[i] = -1; // Empty array. newPolarInitNode->Q_F_N[i] = -1; // Empty array.
nr_polar_info_bit_pattern(newPolarInitNode->information_bit_pattern, nr_polar_info_bit_pattern(newPolarInitNode->information_bit_pattern,
newPolarInitNode->Q_I_N, newPolarInitNode->Q_I_N,
newPolarInitNode->Q_F_N, newPolarInitNode->Q_F_N,
J, J,
newPolarInitNode->Q_0_Nminus1, newPolarInitNode->Q_0_Nminus1,
newPolarInitNode->K, newPolarInitNode->K,
newPolarInitNode->N, newPolarInitNode->N,
newPolarInitNode->encoderLength, newPolarInitNode->encoderLength,
newPolarInitNode->n_pc); newPolarInitNode->n_pc);
// sort the Q_I_N array in ascending order (first K positions) // sort the Q_I_N array in ascending order (first K positions)
qsort((void *)newPolarInitNode->Q_I_N,newPolarInitNode->K,sizeof(int16_t),intcmp); qsort((void *)newPolarInitNode->Q_I_N,newPolarInitNode->K,sizeof(int16_t),intcmp);
newPolarInitNode->channel_interleaver_pattern = malloc(sizeof(uint16_t) * newPolarInitNode->encoderLength); newPolarInitNode->channel_interleaver_pattern = malloc(sizeof(uint16_t) * newPolarInitNode->encoderLength);
nr_polar_channel_interleaver_pattern(newPolarInitNode->channel_interleaver_pattern, nr_polar_channel_interleaver_pattern(newPolarInitNode->channel_interleaver_pattern,
newPolarInitNode->i_bil, newPolarInitNode->i_bil,
newPolarInitNode->encoderLength); newPolarInitNode->encoderLength);
if (decoder_flag == 1) if (decoder_flag == 1)
build_decoder_tree(newPolarInitNode); build_decoder_tree(newPolarInitNode);
build_polar_tables(newPolarInitNode); build_polar_tables(newPolarInitNode);
init_polar_deinterleaver_table(newPolarInitNode); init_polar_deinterleaver_table(newPolarInitNode);
//printf("decoder tree nodes %d\n",newPolarInitNode->tree.num_nodes); //printf("decoder tree nodes %d\n",newPolarInitNode->tree.num_nodes);
} else {
AssertFatal(1 == 0, "[nr_polar_init] New t_nrPolar_params * could not be created");
}
newPolarInitNode->nextPtr=PolarList; newPolarInitNode->nextPtr=PolarList;
PolarList=newPolarInitNode; PolarList=newPolarInitNode;
pthread_mutex_unlock(&PolarListMutex);
return newPolarInitNode; return newPolarInitNode;
} }
......
...@@ -147,7 +147,7 @@ void do_OFDM_mod_l(int32_t **txdataF, int32_t **txdata, uint16_t next_slot, LTE_ ...@@ -147,7 +147,7 @@ void do_OFDM_mod_l(int32_t **txdataF, int32_t **txdata, uint16_t next_slot, LTE_
} }
void DL_channel(RU_t *ru,PHY_VARS_UE *UE,uint subframe,int awgn_flag,double SNR, int tx_lev,int hold_channel,int abstx, int num_rounds, int trials, int round, channel_desc_t *eNB2UE[4], void DL_channel(RU_t *ru,PHY_VARS_UE *UE,uint subframe,int awgn_flag,double SNR, int tx_lev,int hold_channel,int abstx, int num_rounds, int trials, int round, channel_desc_t *eNB2UE[4],
double *s_re[2],double *s_im[2],double *r_re[2],double *r_im[2],FILE *csv_fd) { double *s_re[NB_ANTENNAS_TX],double *s_im[[NB_ANTENNAS_TX],double *r_re[NB_ANTENNAS_RX],double *r_im[NB_ANTENNAS_RX],FILE *csv_fd) {
int i,u; int i,u;
int aa,aarx,aatx; int aa,aarx,aatx;
double channelx,channely; double channelx,channely;
......
...@@ -340,10 +340,10 @@ int main(int argc, char **argv) { ...@@ -340,10 +340,10 @@ int main(int argc, char **argv) {
double s_re1[30720],s_im1[30720],r_re1[30720],r_im1[30720]; double s_re1[30720],s_im1[30720],r_re1[30720],r_im1[30720];
double r_re2[30720],r_im2[30720]; double r_re2[30720],r_im2[30720];
double r_re3[30720],r_im3[30720]; double r_re3[30720],r_im3[30720];
double *s_re[2]= {s_re0,s_re1}; double *s_re[NB_ANTENNAS_TX]= {s_re0,s_re1, NULL, NULL};
double *s_im[2]= {s_im0,s_im1}; double *s_im[NB_ANTENNAS_TX]= {s_im0,s_im1, NULL, NULL};
double *r_re[4]= {r_re0,r_re1,r_re2,r_re3}; double *r_re[NB_ANTENNAS_RX]= {r_re0,r_re1,r_re2,r_re3};
double *r_im[4]= {r_im0,r_im1,r_im2,r_im3}; double *r_im[NB_ANTENNAS_RX]= {r_im0,r_im1,r_im2,r_im3};
double forgetting_factor=0.0; //in [0,1] 0 means a new channel every time, 1 means keep the same channel double forgetting_factor=0.0; //in [0,1] 0 means a new channel every time, 1 means keep the same channel
double iqim=0.0; double iqim=0.0;
int cqi_error,cqi_errors,ack_errors,cqi_crc_falsepositives,cqi_crc_falsenegatives; int cqi_error,cqi_errors,ack_errors,cqi_crc_falsepositives,cqi_crc_falsenegatives;
......
...@@ -1096,7 +1096,8 @@ static int _nas_message_decrypt( ...@@ -1096,7 +1096,8 @@ static int _nas_message_decrypt(
"Unknown security header type %u", security_header_type); "Unknown security header type %u", security_header_type);
LOG_FUNC_RETURN (0); LOG_FUNC_RETURN (0);
}; };
LOG_FUNC_RETURN (0);
} }
/**************************************************************************** /****************************************************************************
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment