diff --git a/cmake_targets/CMakeLists.txt b/cmake_targets/CMakeLists.txt index ac934cee8e..9611ee0e27 100644 --- a/cmake_targets/CMakeLists.txt +++ b/cmake_targets/CMakeLists.txt @@ -1132,7 +1132,7 @@ set(PHY_POLARSRC ${OPENAIR1_DIR}/PHY/CODING/nrPolar_tools/nr_crc_byte.c ${OPENAIR1_DIR}/PHY/CODING/nrPolar_tools/nr_polar_bit_insertion.c ${OPENAIR1_DIR}/PHY/CODING/nrPolar_tools/nr_polar_channel_interleaver_pattern.c - ${OPENAIR1_DIR}/PHY/CODING/nrPolar_tools/nr_polar_crc.c + # ${OPENAIR1_DIR}/PHY/CODING/nrPolar_tools/nr_polar_crc.c ${OPENAIR1_DIR}/PHY/CODING/nrPolar_tools/nr_polar_decoding_tools.c ${OPENAIR1_DIR}/PHY/CODING/nrPolar_tools/nr_polar_info_bit_pattern.c ${OPENAIR1_DIR}/PHY/CODING/nrPolar_tools/nr_polar_interleaving_pattern.c @@ -2547,7 +2547,10 @@ target_link_libraries (dlsim_tm4 ) add_executable(polartest ${OPENAIR1_DIR}/PHY/CODING/TESTBENCH/polartest.c) -target_link_libraries(polartest m SIMU PHY PHY_NR -lm ${ATLAS_LIBRARIES}) +target_link_libraries(polartest m SIMU PHY PHY_NR PHY_COMMON -lm ${ATLAS_LIBRARIES}) + +add_executable(ldpctest ${OPENAIR1_DIR}/PHY/CODING/TESTBENCH/ldpctest.c) +target_link_libraries(ldpctest m SIMU PHY PHY_NR ${ATLAS_LIBRARIES}) add_executable(ldpctest ${OPENAIR1_DIR}/PHY/CODING/TESTBENCH/ldpctest.c) target_link_libraries(ldpctest m SIMU PHY PHY_NR ${ATLAS_LIBRARIES}) diff --git a/openair1/PHY/CODING/TESTBENCH/polartest.c b/openair1/PHY/CODING/TESTBENCH/polartest.c index 736eeec659..144b63b353 100644 --- a/openair1/PHY/CODING/TESTBENCH/polartest.c +++ b/openair1/PHY/CODING/TESTBENCH/polartest.c @@ -8,6 +8,7 @@ #include "PHY/CODING/nrPolar_tools/nr_polar_defs.h" #include "PHY/CODING/nrPolar_tools/nr_polar_pbch_defs.h" +#include "PHY/CODING/nrPolar_tools/nr_polar_uci_defs.h" #include "SIMULATION/TOOLS/sim.h" int main(int argc, char *argv[]) { @@ -32,7 +33,7 @@ int main(int argc, char *argv[]) { uint8_t decoderListSize = 8, pathMetricAppr = 0; //0 --> eq. (8a) and (11b), 1 --> eq. (9) and (12) - while ((arguments = getopt (argc, argv, "s:d:f:m:i:l:a:")) != -1) + while ((arguments = getopt (argc, argv, "s:d:f:m:i:l:a:h")) != -1) switch (arguments) { case 's': @@ -64,21 +65,33 @@ int main(int argc, char *argv[]) { pathMetricAppr = (uint8_t) atoi(optarg); break; + case 'h': + printf("./polartest -s SNRstart -d SNRinc -f SNRstop -m [0=DCI|1=PBCH|2=UCI] -i iterations -l decoderListSize -a pathMetricAppr\n"); + exit(-1); + default: perror("[polartest.c] Problem at argument parsing with getopt"); - abort (); + exit(-1); } if (polarMessageType == 0) { //DCI - //testLength = ; - //coderLength = ; + //testLength = ; + //coderLength = ; + printf("polartest for DCI not supported yet\n"); + exit(-1); } else if (polarMessageType == 1) { //PBCH - testLength = NR_POLAR_PBCH_PAYLOAD_BITS; - coderLength = NR_POLAR_PBCH_E; + testLength = NR_POLAR_PBCH_PAYLOAD_BITS; + coderLength = NR_POLAR_PBCH_E; + printf("running polartest for PBCH\n"); } else if (polarMessageType == 2) { //UCI - //testLength = ; - //coderLength = ; + testLength = NR_POLAR_PUCCH_PAYLOAD_BITS; + coderLength = NR_POLAR_PUCCH_E; + printf("running polartest for UCI"); + } else { + printf("unsupported polarMessageType %d (0=DCI, 1=PBCH, 2=UCI)\n",polarMessageType); + exit(-1); } + //Logging time_t currentTime; @@ -96,12 +109,12 @@ int main(int argc, char *argv[]) { if (stat(folderName, &folder) == -1) mkdir(folderName, S_IRWXU | S_IRWXG | S_IRWXO); FILE* logFile; - logFile = fopen(fileName, "w"); - if (logFile==NULL) { - fprintf(stderr,"[polartest.c] Problem creating file %s with fopen\n",fileName); - exit(-1); - } - fprintf(logFile,",SNR,nBitError,blockErrorState,t_encoder[us],t_decoder[us]\n"); + logFile = fopen(fileName, "w"); + if (logFile==NULL) { + fprintf(stderr,"[polartest.c] Problem creating file %s with fopen\n",fileName); + exit(-1); + } + fprintf(logFile,",SNR,nBitError,blockErrorState,t_encoder[us],t_decoder[us]\n"); uint8_t *testInput = malloc(sizeof(uint8_t) * testLength); //generate randomly uint8_t *encoderOutput = malloc(sizeof(uint8_t) * coderLength); @@ -121,7 +134,8 @@ int main(int argc, char *argv[]) { SNR_lin = pow(10, SNR/10); for (itr = 1; itr <= iterations; itr++) { - for(int i=0; i D^6+D^5+1 +uint32_t poly11 = 0xc4200000; //11000100001000... -> D^11+D^10+D^9+D^5+1 + /********************************************************* For initialization && verification purposes, @@ -93,6 +96,18 @@ void crcTableInit (void) crc8Table[c] = (unsigned char) (crcbit (&c, 1, poly8) >> 24); } while (++c); } + +//Generic version +void crcTable256Init (uint32_t poly, uint32_t* crc256Table) +{ + unsigned char c = 0; + + do { + crc256Table[c] = crcbit(&c, 1, poly); + } while (++c); + +} + /********************************************************* Byte by byte implementations, @@ -193,6 +208,70 @@ crc8 (unsigned char * inptr, int bitlen) return crc; } +//Generic version +unsigned int crcPayload(unsigned char * inptr, int bitlen, uint32_t* crc256Table) +{ + int octetlen, resbit; + unsigned int crc = 0; + octetlen = bitlen/8; // Change in bytes + resbit = (bitlen % 8); + + while (octetlen-- > 0) + { + crc = (crc << 8) ^ crc256Table[(*inptr++) ^ (crc >> 24)]; + } + + if (resbit > 0) + { + crc = (crc << resbit) ^ crc256Table[((*inptr) >> (8 - resbit)) ^ (crc >> (32 - resbit))]; + } + return crc; +} + +void nr_crc_computation(uint8_t* input, uint8_t* output, uint16_t payloadBits, uint16_t crcParityBits, uint32_t* crc256Table) +{ + //Create payload in bit + uint8_t* input2 = (uint8_t*)malloc(payloadBits); //divided by 8 (in bits) + uint8_t mask = 128; // 10000000 + + for(uint8_t ind=0; ind<(payloadBits/8); ind++) + { + input2[ind]=0; + for(uint8_t ind2=0; ind2<8; ind2++) + { + if(input[8*ind+ind2]) + { + input2[ind] = input2[ind] | mask; + } + mask= mask >> 1; + } + mask=128; + } + + //crcTable256Init(poly); + + unsigned int crcBits; + crcBits = crcPayload(input2, payloadBits, crc256Table); + + //create crc in byte + unsigned int mask2=0x80000000; //100... + + for(uint8_t ind=0; ind> 1; + } + +} + + + + + #ifdef DEBUG_CRC /*******************************************************************/ /** diff --git a/openair1/PHY/CODING/nrPolar_init.c b/openair1/PHY/CODING/nrPolar_init.c index 6f5b167c0e..65422ee073 100644 --- a/openair1/PHY/CODING/nrPolar_init.c +++ b/openair1/PHY/CODING/nrPolar_init.c @@ -21,9 +21,17 @@ #include "nrPolar_tools/nr_polar_defs.h" #include "nrPolar_tools/nr_polar_pbch_defs.h" +#include "nrPolar_tools/nr_polar_uci_defs.h" void nr_polar_init(t_nrPolar_params* polarParams, int messageType) { +uint32_t poly6 = 0x84000000; // 1000100000... -> D^6+D^5+1 +uint32_t poly11 = 0x63200000; //11000100001000... -> D^11+D^10+D^9+D^5+1 +uint32_t poly16 = 0x81080000; //100000010000100... - > D^16+D^12+D^5+1 +uint32_t poly24a = 0x864cfb00; //100001100100110011111011 -> D^24+D^23+D^18+D^17+D^14+D^11+D^10+D^7+D^6+D^5+D^4+D^3+D+1 +uint32_t poly24b = 0x80006300; //100000000000000001100011 -> D^24+D^23+D^6+D^5+D+1 +uint32_t poly24c = 0xB2B11700; //101100101011000100010111 -> D^24... + if (messageType == 0) { //DCI } else if (messageType == 1) { //PBCH @@ -36,13 +44,13 @@ void nr_polar_init(t_nrPolar_params* polarParams, int messageType) { polarParams->payloadBits = NR_POLAR_PBCH_PAYLOAD_BITS; polarParams->encoderLength = NR_POLAR_PBCH_E; polarParams->crcParityBits = NR_POLAR_PBCH_CRC_PARITY_BITS; - polarParams->crcCorrectionBits = NR_POLAR_PBCH_CRC_ERROR_CORRECTION_BITS; polarParams->K = polarParams->payloadBits + polarParams->crcParityBits; // Number of bits to encode. polarParams->N = nr_polar_output_length(polarParams->K, polarParams->encoderLength, polarParams->n_max); polarParams->n = log2(polarParams->N); polarParams->crc_generator_matrix=crc24c_generator_matrix(polarParams->payloadBits); + polarParams->crc_polynomial = poly24c; polarParams->G_N = nr_polar_kronecker_power_matrices(polarParams->n); //polar_encoder vectors: @@ -55,9 +63,80 @@ void nr_polar_init(t_nrPolar_params* polarParams, int messageType) { polarParams->nr_polar_cPrime = malloc(sizeof(uint8_t) * polarParams->K); //Decoder: nr_polar_cHat polarParams->nr_polar_b = malloc(sizeof(uint8_t) * polarParams->K); //Decoder: nr_polar_bHat } else if (messageType == 2) { //UCI + polarParams->payloadBits = NR_POLAR_PUCCH_PAYLOAD_BITS; //A depends on what they carry... + polarParams->encoderLength = NR_POLAR_PUCCH_E ; //E depends on other standards 6.3.1.4 + + if (polarParams->payloadBits <= 11) //Ref. 38-212, Section 6.3.1.2.2 + polarParams->crcParityBits = 0; //K=A + else //Ref. 38-212, Section 6.3.1.2.1 + { + if (polarParams->payloadBits < 20) + polarParams->crcParityBits = NR_POLAR_PUCCH_CRC_PARITY_BITS_SHORT; + else + polarParams->crcParityBits = NR_POLAR_PUCCH_CRC_PARITY_BITS_LONG; + if (polarParams->payloadBits >= 360 && polarParams->encoderLength >= 1088) + polarParams->i_seg = NR_POLAR_PUCCH_I_SEG_LONG; // -> C=2 + else + polarParams->i_seg = NR_POLAR_PUCCH_I_SEG_SHORT; // -> C=1 + } + + polarParams->K = polarParams->payloadBits + polarParams->crcParityBits; // Number of bits to encode. + + //K_r = K/C ; C = I_seg+1 + if((polarParams->K)/(polarParams->i_seg+1)>=18 && (polarParams->K)/(polarParams->i_seg+1)<=25) //Ref. 38-212, Section 6.3.1.3.1 + { + polarParams->n_max = NR_POLAR_PUCCH_N_MAX; + polarParams->i_il =NR_POLAR_PUCCH_I_IL; + polarParams->n_pc = NR_POLAR_PUCCH_N_PC_SHORT; + + if( (polarParams->encoderLength - polarParams->K)/(polarParams->i_seg + 1) + 3 > 192 ) + polarParams->n_pc_wm = NR_POLAR_PUCCH_N_PC_WM_LONG; + else + polarParams->n_pc_wm = NR_POLAR_PUCCH_N_PC_WM_SHORT; + } + + if( (polarParams->K)/(polarParams->i_seg + 1) > 30 ) //Ref. 38-212, Section 6.3.1.3.1 + { + polarParams->n_max = NR_POLAR_PUCCH_N_MAX; + polarParams->i_il =NR_POLAR_PUCCH_I_IL; + polarParams->n_pc = NR_POLAR_PUCCH_N_PC_LONG; + polarParams->n_pc_wm = NR_POLAR_PUCCH_N_PC_WM_LONG; + } + + polarParams->i_bil = NR_POLAR_PUCCH_I_BIL; //Ref. 38-212, Section 6.3.1.4.1 + + polarParams->N = nr_polar_output_length(polarParams->K, polarParams->encoderLength, polarParams->n_max); + polarParams->n = log2(polarParams->N); + + if((polarParams->payloadBits) <= 19) + { + polarParams->crc_generator_matrix=crc6_generator_matrix(polarParams->payloadBits); + polarParams->crc_polynomial = poly6; + + } + else + { + polarParams->crc_generator_matrix=crc11_generator_matrix(polarParams->payloadBits); + polarParams->crc_polynomial = poly11; + } + polarParams->G_N = nr_polar_kronecker_power_matrices(polarParams->n); + + //polar_encoder vectors: + polarParams->nr_polar_crc = malloc(sizeof(uint8_t) * polarParams->crcParityBits); + polarParams->nr_polar_cPrime = malloc(sizeof(uint8_t) * polarParams->K); + polarParams->nr_polar_d = malloc(sizeof(uint8_t) * polarParams->N); + + //Polar Coding vectors + polarParams->nr_polar_u = malloc(sizeof(uint8_t) * polarParams->N); //Decoder: nr_polar_uHat + polarParams->nr_polar_cPrime = malloc(sizeof(uint8_t) * polarParams->K); //Decoder: nr_polar_cHat + polarParams->nr_polar_b = malloc(sizeof(uint8_t) * polarParams->K); //Decoder: nr_polar_bHat } + polarParams->crcCorrectionBits = NR_POLAR_CRC_ERROR_CORRECTION_BITS; + + polarParams->crc256Table = malloc(sizeof(uint32_t)*256); + crcTable256Init(polarParams->crc_polynomial, polarParams->crc256Table); polarParams->Q_0_Nminus1 = nr_polar_sequence_pattern(polarParams->n); polarParams->interleaving_pattern = malloc(sizeof(uint16_t) * polarParams->K); diff --git a/openair1/PHY/CODING/nrPolar_tools/nr_crc_byte.c b/openair1/PHY/CODING/nrPolar_tools/nr_crc_byte.c index 18d416b980..7b5a1c922a 100644 --- a/openair1/PHY/CODING/nrPolar_tools/nr_crc_byte.c +++ b/openair1/PHY/CODING/nrPolar_tools/nr_crc_byte.c @@ -21,6 +21,133 @@ #include "PHY/CODING/nrPolar_tools/nr_polar_defs.h" +/* +// ----- New implementation ---- +uint32_t poly6 = 0x84000000; // 10000100000... -> D^6+D^5+1 +uint32_t poly11 = 0xc4200000; //11000100001000... -> D^11+D^10+D^9+D^5+1 +uint32_t poly16 = 0x10210000; //00100000010000100... - > D^16+D^12+D^5+1 +uint32_t poly24a = 0x864cfb00; //100001100100110011111011 -> D^24+D^23+D^18+D^17+D^14+D^11+D^10+D^7+D^6+D^5+D^4+D^3+D+1 +uint32_t poly24b = 0x80006300; //100000000000000001100011 -> D^24+D^23+D^6+D^5+D+1 +uint32_t poly24c = 0xB2B11700; //101100101011000100010111 -> D^24... + +//static unsigned int crc256Table[256]; + +void nr_crc_computation(uint8_t* input, uint8_t* output, uint16_t payloadBits, uint16_t crcParityBits, uint32_t* crc256Table) +{ + //Create payload in bit + uint8_t* input2 = (uint8_t*)malloc(payloadBits); //divided by 8 (in bits) + uint8_t mask = 128; // 10000000 + + for(uint8_t ind=0; ind<(payloadBits/8); ind++) + { + input2[ind]=0; + for(uint8_t ind2=0; ind2<8; ind2++) + { + if(input[8*ind+ind2]) + { + input2[ind] = input2[ind] | mask; + } + mask= mask >> 1; + } + mask=128; + } + + //crcTable256Init(poly); + + unsigned int crcBits; + crcBits = crcPayload(input2, payloadBits, crc256Table); + + //create crc in byte + unsigned int mask2=0x80000000; //100... + output = (uint8_t*)malloc(sizeof(uint8_t)*crcParityBits); + + for(uint8_t ind=0; ind> 1; + } + +} + +unsigned int crcbit (unsigned char* inputptr, int octetlen, unsigned int poly) +{ + unsigned int i, crc = 0, c; + + while (octetlen-- > 0) { + c = (*inputptr++) << 24; + + for (i = 8; i != 0; i--) { + if ((1 << 31) & (c ^ crc)) + crc = (crc << 1) ^ poly; + else + crc <<= 1; + + c <<= 1; + } + } + + return crc; +} + +void crcTableInit (void) +{ + unsigned char c = 0; + + do { + crc6Table[c] = crcbit(&c, 1, poly6); + crc11Table[c]= crcbit(&c, 1, poly11); + crc16Table[c] =crcbit(&c, 1, poly16); + crc24aTable[c]=crcbit(&c, 1, poly24a); + crc24bTable[c]=crcbit(&c, 1, poly24b); + crc24cTable[c]=crcbit(&c, 1, poly24c); + + } while (++c); +} + +void crcTable256Init (uint32_t poly, uint32_t* crc256Table) +{ + unsigned char c = 0; +// crc256Table = malloc(sizeof(uint32_t)*256); + + do { + crc256Table[c] = crcbit(&c, 1, poly); + +// crc6Table[c] = crcbit(&c, 1, poly6); + // crc11Table[c]= crcbit(&c, 1, poly11); +// crc16Table[c] =crcbit(&c, 1, poly16); +// crc24aTable[c]=crcbit(&c, 1, poly24a); +// crc24bTable[c]=crcbit(&c, 1, poly24b); +// crc24cTable[c]=crcbit(&c, 1, poly24c); + + } while (++c); + + //return crc256Table; +} + +unsigned int crcPayload(unsigned char * inptr, int bitlen, uint32_t* crc256Table) +{ + int octetlen, resbit; + unsigned int crc = 0; + octetlen = bitlen/8; // Change in bytes + resbit = (bitlen % 8); + + while (octetlen-- > 0) + { + crc = (crc << 8) ^ crc256Table[(*inptr++) ^ (crc >> 24)]; + } + + if (resbit > 0) + { + crc = (crc << resbit) ^ crc256Table[((*inptr) >> (8 - resbit)) ^ (crc >> (32 - resbit))]; + } + return crc; +} +*/ +// ----- Old implementation ---- uint8_t **crc24c_generator_matrix(uint16_t payloadSizeBits){ uint8_t crcPolynomialPattern[25] = {1,1,0,1,1,0,0,1,0,1,0,1,1,0,0,0,1,0,0,0,1,0,1,1,1}; diff --git a/openair1/PHY/CODING/nrPolar_tools/nr_polar_defs.h b/openair1/PHY/CODING/nrPolar_tools/nr_polar_defs.h index 0db26f6f35..7caf547395 100644 --- a/openair1/PHY/CODING/nrPolar_tools/nr_polar_defs.h +++ b/openair1/PHY/CODING/nrPolar_tools/nr_polar_defs.h @@ -19,6 +19,8 @@ * contact@openairinterface.org */ +#define NR_POLAR_CRC_ERROR_CORRECTION_BITS 3 + #ifndef __NR_POLAR_DEFS__H__ #define __NR_POLAR_DEFS__H__ @@ -53,9 +55,11 @@ struct nrPolar_params { int16_t *Q_PC_N; uint8_t *information_bit_pattern; uint16_t *channel_interleaver_pattern; + uint32_t crc_polynomial; uint8_t **crc_generator_matrix; //G_P uint8_t **G_N; + uint32_t* crc256Table; //polar_encoder vectors: uint8_t *nr_polar_crc; @@ -68,6 +72,8 @@ typedef struct nrPolar_params t_nrPolar_params; void polar_encoder(uint8_t *input, uint8_t *output, t_nrPolar_params* polarParams); +void nr_polar_kernal_operation(uint8_t *u, uint8_t *d, uint16_t N); + int8_t polar_decoder(double *input, uint8_t *output, t_nrPolar_params *polarParams, uint8_t listSize, double *aPrioriPayload, uint8_t pathMetricAppr); @@ -135,6 +141,11 @@ uint8_t **crc24c_generator_matrix(uint16_t payloadSizeBits); uint8_t **crc11_generator_matrix(uint16_t payloadSizeBits); uint8_t **crc6_generator_matrix(uint16_t payloadSizeBits); +void crcTable256Init (uint32_t poly, uint32_t* crc256Table); +void nr_crc_computation(uint8_t* input, uint8_t* output, uint16_t payloadBits, uint16_t crcParityBits, uint32_t* crc256Table); +unsigned int crcbit (unsigned char* inputptr, int octetlen, uint32_t poly); +unsigned int crcPayload(unsigned char * inptr, int bitlen, uint32_t* crc256Table); + static inline void nr_polar_rate_matcher(uint8_t *input, unsigned char *output, uint16_t *pattern, uint16_t size) { for (int i=0; icrc_generator_matrix, - polarParams->nr_polar_crc, polarParams->payloadBits, polarParams->crcParityBits); - for (uint8_t i = 0; i < polarParams->crcParityBits; i++) polarParams->nr_polar_crc[i] = (polarParams->nr_polar_crc[i] % 2); + // --- OLD --- + //nr_matrix_multiplication_uint8_t_1D_uint8_t_2D(input, polarParams->crc_generator_matrix, + // polarParams->nr_polar_crc, polarParams->payloadBits, polarParams->crcParityBits); + //for (uint8_t i = 0; i < polarParams->crcParityBits; i++) polarParams->nr_polar_crc[i] = (polarParams->nr_polar_crc[i] % 2); + + // --- NEW --- + nr_crc_computation(input, polarParams->nr_polar_crc, polarParams->payloadBits, polarParams->crcParityBits, polarParams->crc256Table); + //Attach CRC to the Transport Block. (a to b) for (uint16_t i = 0; i < polarParams->payloadBits; i++) polarParams->nr_polar_b[i] = input[i]; @@ -50,8 +55,19 @@ void polar_encoder( polarParams->Q_I_N, polarParams->Q_PC_N, polarParams->n_pc); //Encoding (u to d) - nr_matrix_multiplication_uint8_t_1D_uint8_t_2D(polarParams->nr_polar_u, polarParams->G_N, polarParams->nr_polar_d, polarParams->N, polarParams->N); - for (uint16_t i = 0; i < polarParams->N; i++) polarParams->nr_polar_d[i] = (polarParams->nr_polar_d[i] % 2); + // --- OLD --- + //nr_matrix_multiplication_uint8_t_1D_uint8_t_2D(polarParams->nr_polar_u, polarParams->G_N, polarParams->nr_polar_d, polarParams->N, polarParams->N); + //for (uint16_t i = 0; i < polarParams->N; i++) polarParams->nr_polar_d[i] = (polarParams->nr_polar_d[i] % 2); + //printf("\nd old: "); + //for (uint16_t i = 0; i < polarParams->N; i++) + //printf("%i ", polarParams->nr_polar_d[i]); + + // --- NEW --- + nr_polar_kernal_operation(polarParams->nr_polar_u, polarParams->nr_polar_d, polarParams->N); + //printf("\nd new: "); + //for (uint16_t i = 0; i < polarParams->N; i++) + // printf("%i ", polarParams->nr_polar_d[i]); + //for (uint16_t i = 0; i < polarParams->N; i++) polarParams->nr_polar_d[i] = (polarParams->nr_polar_d[i] % 2); //Rate matching //Sub-block interleaving (d to y) and Bit selection (y to e) diff --git a/openair1/PHY/CODING/nrPolar_tools/nr_polar_kernal_operation.c b/openair1/PHY/CODING/nrPolar_tools/nr_polar_kernal_operation.c index 0584d98afa..5985130eee 100644 --- a/openair1/PHY/CODING/nrPolar_tools/nr_polar_kernal_operation.c +++ b/openair1/PHY/CODING/nrPolar_tools/nr_polar_kernal_operation.c @@ -3,21 +3,73 @@ #include #include -void nr_polar_kernel_operation(uint8_t *u, uint8_t *d, uint16_t N) +#include + +void nr_polar_kernal_operation(uint8_t *u, uint8_t *d, uint16_t N) { - // Martino's algorithm to avoid multiplication for the generating matrix + // Martino's algorithm to avoid multiplication for the generating matrix of polar codes + + uint32_t i,j; - int i,j; - printf("\nd = "); - for(i=0; i If zero, then XOR with the u(j) + D=_mm256_cmpeq_epi32(C, zerosOnly); // compare with zero and use the result as mask + + E=_mm256_maskload_epi32((int const*)uArray, D); // load only some u(j)s for the XOR + OUT=_mm256_xor_si256(OUT, E); //32 bit x 8 + + } + _mm256_storeu_si256((__m256i*)dTest, OUT); + + for(k=0; k<8; k++) // Conversion from 32 bits to 8 bits + { + d[i+k]=(uint8_t)dTest[k]; // With AVX512 there is an intrinsic to do it + } + + } + + #else + + for(i=0; i