Merge branch 'nr_polar_uci' into develop-nr

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})

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,22 +65,34 @@ 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 = ;
+	  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;
+	  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;
 	time (&currentTime);
@@ -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<testLength; i++) testInput[i]=(uint8_t) (rand() % 2);
+		for(int i=0; i<testLength; i++) 
+			testInput[i]=(uint8_t) (rand() % 2);
 
 		start_meas(&timeEncoder);
 		polar_encoder(testInput, encoderOutput, &nrPolar_params);

openair1/PHY/CODING/crc_byte.c

@@ -33,14 +33,17 @@
 
 #include "coding_defs.h"
 
-
 /*ref 36-212 v8.6.0 , pp 8-9 */
 /* the highest degree is set by default */
 unsigned int             poly24a = 0x864cfb00;   //1000 0110 0100 1100 1111 1011  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
 unsigned int             poly24b = 0x80006300;    // 1000 0000 0000 0000 0110 0011  D^24 + D^23 + D^6 + D^5 + D + 1
+uint32_t poly24c = 0xB2B11700; //101100101011000100010111
 unsigned int             poly16 = 0x10210000;    // 0001 0000 0010 0001            D^16 + D^12 + D^5 + 1
 unsigned int             poly12 = 0x80F00000;    // 1000 0000 1111                 D^12 + D^11 + D^3 + D^2 + D + 1
 unsigned int             poly8 = 0x9B000000;     // 1001 1011                      D^8  + D^7  + D^4 + D^3 + D + 1
+uint32_t poly6 = 0x84000000; // 10000100000... -> 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<crcParityBits; ind++)
+        {
+                if(crcBits & mask2)
+                        output[ind]=1;
+                else
+                        output[ind]=0;
+
+		mask2 = mask2 >> 1;
+        }
+      
+}
+
+
+
+
+
 #ifdef DEBUG_CRC
 /*******************************************************************/
 /**

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);

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<crcParityBits; ind++)
+        {
+		if(crcBits & mask2)
+			output[ind]=1;
+		else
+			output[ind]=0;
+
+		mask2 = mask2 >> 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};

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; i<size; i++) output[i]=input[pattern[i]];
 }

openair1/PHY/CODING/nrPolar_tools/nr_polar_encoder.c

@@ -33,9 +33,14 @@ void polar_encoder(
 	 */
 
 	//Calculate CRC.
-	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);
+	// --- 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)

openair1/PHY/CODING/nrPolar_tools/nr_polar_kernal_operation.c

@@ -3,21 +3,73 @@
 #include <math.h>
 #include <stdint.h>
 
-void nr_polar_kernel_operation(uint8_t *u, uint8_t *d, uint16_t N)
+#include <immintrin.h>
+
+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;
+
+	#ifdef __AVX2__
+
+	__m256i A,B,C,D,E,U,zerosOnly, OUT;
+	__m256i inc;
+	uint32_t dTest[8];
+	uint32_t uArray[8];
+	uint32_t k;	
+	uint32_t incArray[8];
 	
-    int i,j;
-    printf("\nd = ");
-	for(i=0; i<N; i++)
+	//initialisation
+	for(k=0; k<8; k++)
+		incArray[k]=k;
+	inc=_mm256_loadu_si256((__m256i const*)incArray); // 0, 1, ..., 7 to increase
+	
+	zerosOnly=_mm256_setzero_si256(); // for comparison
+
+	for(i=0; i<N; i+=8)
         {
-        d[i]=0;
+		B=_mm256_set1_epi32((int)i); // i, ..., i
+		B=_mm256_add_epi32(B, inc); // i, i+1, ..., i+7
+		
+		OUT=_mm256_setzero_si256(); // it will contain the result of all the XORs for the d(i)s
+                
 		for(j=0; j<N; j++)
 		{
-            d[i]=d[i]+(( (j-i)& i )==0)*u[j];
+			A=_mm256_set1_epi32((int)(j)); //j, j,  ..., j
+			A=_mm256_sub_epi32(A, B); //(j-i), (j-(i+1)), ... (j-(i+7))  
+			
+			U=_mm256_set1_epi32((int)u[j]);
+			_mm256_storeu_si256((__m256i*)uArray, U); //u(j) ... u(j) for the maskload
+
+			C=_mm256_and_si256(A, B); //(j-i)&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
+
 		}
-        d[i]=d[i]%2;
+		_mm256_storeu_si256((__m256i*)dTest, OUT);
 
-        printf("%i", d[i]);
+		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<N; i++) // Create the elements of d=u*G_N ...
+        {
+                d[i]=0;
+                for(j=0; j<N; j++) // ... looking at all the elements of u
+                {
+                        d[i]=d[i] ^ (!( (j-i)& i ))*u[j];
+                        // it's like ((j-i)&i)==0
                 }
+        }
+	
+	#endif
+
 }

openair1/PHY/CODING/nrPolar_tools/nr_polar_uci_defs.h

@@ -33,4 +33,27 @@
 #ifndef __NR_POLAR_UCI_DEFS__H__
 #define __NR_POLAR_UCI_DEFS__H__
 
+#define NR_POLAR_PUCCH_PAYLOAD_BITS 32
+#define NR_POLAR_PUCCH_E 32
+
+//Ref. 38-212, Section 6.3.1.2.1
+#define NR_POLAR_PUCCH_CRC_PARITY_BITS_SHORT 6
+#define NR_POLAR_PUCCH_CRC_PARITY_BITS_LONG 11
+
+#define NR_POLAR_PUCCH_I_SEG_LONG 1
+#define NR_POLAR_PUCCH_I_SEG_SHORT 0
+
+//Ref. 38-212, Section 6.3.1.3.1
+#define NR_POLAR_PUCCH_N_MAX 10
+#define NR_POLAR_PUCCH_I_IL 0
+#define NR_POLAR_PUCCH_N_PC_SHORT 3
+#define NR_POLAR_PUCCH_N_PC_LONG 0
+#define NR_POLAR_PUCCH_N_PC_WM_LONG 0
+#define NR_POLAR_PUCCH_N_PC_WM_SHORT 1
+
+//Ref. 38-212, Section 6.3.1.4.1
+#define NR_POLAR_PUCCH_I_BIL 1
+
+
+
 #endif