polar coding for UCI (PUCCH) integrated into polartest for lengths 12...64

openair1/PHY/CODING/TESTBENCH/polartest.c

@@ -27,7 +27,7 @@ int main(int argc, char *argv[])
 {
   //Default simulation values (Aim for iterations = 1000000.)
   int decoder_int16=0;
-  int itr, iterations = 1000, arguments, polarMessageType = 0; //0=PBCH, 1=DCI, -1=UCI
+  int itr, iterations = 1000, arguments, polarMessageType = 0; //0=PBCH, 1=DCI, 2=UCI
   double SNRstart = -20.0, SNRstop = 0.0, SNRinc= 0.5; //dB
   double SNR, SNR_lin;
   int16_t nBitError = 0; // -1 = Decoding failed (All list entries have failed the CRC checks).
@@ -42,6 +42,7 @@ int main(int argc, char *argv[])
     switch (arguments) {
     case 's':
     	SNRstart = atof(optarg);
+	SNRstop = SNRstart + 2;
     	break;
 
     case 'd':
@@ -91,7 +92,7 @@ int main(int argc, char *argv[])
 
     case 'k':
     	testLength=atoi(optarg);
-    	if (testLength < 12 || testLength > 60) {
+    	if (testLength < 12 || testLength > 127) {
     		printf("Illegal packet bitlength %d \n",testLength);
     		exit(-1);
     	}
@@ -123,9 +124,10 @@ int main(int argc, char *argv[])
 	  aggregation_level = NR_POLAR_PBCH_AGGREGATION_LEVEL;
   } else if (polarMessageType == 1) { //DCI
 	  coderLength = 108*aggregation_level;
-  } else if (polarMessageType == -1) { //UCI
-	  printf("UCI testing not supported yet\n");
-	  exit(-1);
+  } else if (polarMessageType == 2) { //UCI
+    //pucch2 parameters, 1 symbol, aggregation_level = NPRB
+    AssertFatal(aggregation_level>2,"For UCI formats, aggregation (N_RB) should be > 2\n");
+    coderLength = 16*aggregation_level; 
   }
 
   //Logging

openair1/PHY/CODING/coding_defs.h

@@ -382,12 +382,24 @@ unsigned int crc16 (unsigned char * inptr, int bitlen);
 @param bitlen length of inputs in bits*/
 unsigned int crc12 (unsigned char * inptr, int bitlen);
 
+/*!\fn uint32_t crc12(uint8_t *inPtr, int32_t bitlen)
+\brief This computes an 11-bit crc based on 3GPP NR specifications.
+@param inPtr Pointer to input byte stream
+@param bitlen length of inputs in bits*/
+unsigned int crc11 (unsigned char * inptr, int bitlen);
+
 /*!\fn uint32_t crc8(uint8_t *inPtr, int32_t bitlen)
 \brief This computes a 8-bit crc based on 3GPP UMTS specifications.
 @param inPtr Pointer to input byte stream
 @param bitlen length of inputs in bits*/
 unsigned int crc8 (unsigned char * inptr, int bitlen);
 
+/*!\fn uint32_t crc8(uint8_t *inPtr, int32_t bitlen)
+\brief This computes a 6-bit crc based on 3GPP NR specifications.
+@param inPtr Pointer to input byte stream
+@param bitlen length of inputs in bits*/
+unsigned int crc6 (unsigned char * inptr, int bitlen);
+
 int check_crc(uint8_t* decoded_bytes, uint32_t n, uint32_t F, uint8_t crc_type);
     
 /*!\fn void phy_viterbi_dot11_sse2(int8_t *y, uint8_t *decoded_bytes, uint16_t n,int offset,int traceback)

openair1/PHY/CODING/crc_byte.c

@@ -90,7 +90,9 @@ static unsigned int        crc24bTable[256];
 static unsigned int        crc24cTable[256];
 static unsigned short      crc16Table[256];
 static unsigned short      crc12Table[256];
+static unsigned short      crc11Table[256];
 static unsigned char       crc8Table[256];
+static unsigned char       crc6Table[256];
 
 void crcTableInit (void)
 {
@@ -102,7 +104,9 @@ void crcTableInit (void)
     crc24cTable[c] = crcbit (&c, 1, poly24c);
     crc16Table[c] = (unsigned short) (crcbit (&c, 1, poly16) >> 16);
     crc12Table[c] = (unsigned short) (crcbit (&c, 1, poly12) >> 16);
+    crc11Table[c] = (unsigned short) (crcbit (&c, 1, poly11) >> 16);
     crc8Table[c] = (unsigned char) (crcbit (&c, 1, poly8) >> 24);
+    crc6Table[c] = (unsigned char) (crcbit (&c, 1, poly6) >> 24);
   } while (++c);
 }
 
@@ -207,6 +211,24 @@ crc12 (unsigned char * inptr, int bitlen)
   return crc;
 }
 
+unsigned int
+crc11 (unsigned char * inptr, int bitlen)
+{
+  int             octetlen, resbit;
+  unsigned int             crc = 0;
+  octetlen = bitlen / 8;        /* Change in octets */
+  resbit = (bitlen % 8);
+
+  while (octetlen-- > 0) {
+    crc = (crc << 8) ^ (crc11Table[(*inptr++) ^ (crc >> 24)] << 16);
+  }
+
+  if (resbit > 0)
+    crc = (crc << resbit) ^ (crc11Table[((*inptr) >> (8 - resbit)) ^ (crc >> (32 - resbit))] << 16);
+
+  return crc;
+}
+
 unsigned int
 crc8 (unsigned char * inptr, int bitlen)
 {
@@ -225,6 +247,24 @@ crc8 (unsigned char * inptr, int bitlen)
   return crc;
 }
 
+unsigned int
+crc6 (unsigned char * inptr, int bitlen)
+{
+  int             octetlen, resbit;
+  unsigned int             crc = 0;
+  octetlen = bitlen / 8;        /* Change in octets */
+  resbit = (bitlen % 8);
+
+  while (octetlen-- > 0) {
+    crc = crc6Table[(*inptr++) ^ (crc >> 24)] << 24;
+  }
+
+  if (resbit > 0)
+    crc = (crc << resbit) ^ (crc8Table[((*inptr) >> (8 - resbit)) ^ (crc >> (32 - resbit))] << 24);
+
+  return crc;
+}
+
 int check_crc(uint8_t* decoded_bytes, uint32_t n, uint32_t F, uint8_t crc_type)
 {
   uint32_t crc=0,oldcrc=0;

openair1/PHY/CODING/nrPolar_tools/nr_polar_decoder.c

@@ -569,7 +569,7 @@ int8_t polar_decoder_dci(double *input,
 }
 
 void init_polar_deinterleaver_table(t_nrPolar_params *polarParams) {
-  AssertFatal(polarParams->K > 32, "K = %d < 33, is not supported yet\n",polarParams->K);
+  AssertFatal(polarParams->K > 17, "K = %d < 18, is not allowed\n",polarParams->K);
   AssertFatal(polarParams->K < 129, "K = %d > 128, is not supported yet\n",polarParams->K);
   int bit_i,ip,ipmod64;
   int numbytes = polarParams->K>>3;
@@ -670,7 +670,9 @@ uint32_t polar_decoder_int16(int16_t *input,
     A32_flip[1+offset]=((uint8_t *)&Aprime)[2];
     A32_flip[2+offset]=((uint8_t *)&Aprime)[1];
     A32_flip[3+offset]=((uint8_t *)&Aprime)[0];
-    crc = (uint64_t)(crc24c(A32_flip,8*offset+len)>>8);
+    if      (crclen == 24) crc = (uint64_t)((crc24c(A32_flip,8*offset+len)>>8)&0xffffff);
+    else if (crclen == 11) crc = (uint64_t)((crc11(A32_flip,8*offset+len)>>21)&0x7ff);
+    else if (crclen == 6)  crc = (uint64_t)((crc6(A32_flip,8*offset+len)>>26)&0x3f);
   } else if (len<=64) {
     Ar = (B[0]>>crclen) | (B[1]<<(64-crclen));;
     uint8_t A64_flip[8+offset];
@@ -688,7 +690,9 @@ uint32_t polar_decoder_int16(int16_t *input,
     A64_flip[5+offset]=((uint8_t *)&Aprime)[2];
     A64_flip[6+offset]=((uint8_t *)&Aprime)[1];
     A64_flip[7+offset]=((uint8_t *)&Aprime)[0];
-    crc = (uint64_t)(crc24c(A64_flip,8*offset+len)>>8);
+    if      (crclen==24) crc = (uint64_t)(crc24c(A64_flip,8*offset+len)>>8)&0xffffff;
+    else if (crclen==11) crc = (uint64_t)(crc11(A64_flip,8*offset+len)>>21)&0x7ff;
+    else if (crclen==6) crc = (uint64_t)(crc6(A64_flip,8*offset+len)>>26)&0x3f;
   }
 
 #if 0

openair1/PHY/CODING/nrPolar_tools/nr_polar_encoder.c

@@ -295,8 +295,8 @@ static inline void polar_rate_matching(t_nrPolar_params *polarParams,void *in,vo
 
 void build_polar_tables(t_nrPolar_params *polarParams) {
   // build table b -> c'
-  AssertFatal(polarParams->K > 32, "K = %d < 33, is not supported yet\n",polarParams->K);
-  AssertFatal(polarParams->K < 129, "K = %d > 64, is not supported yet\n",polarParams->K);
+  AssertFatal(polarParams->K > 17, "K = %d < 18, is not possible\n",polarParams->K);
+  AssertFatal(polarParams->K < 129, "K = %d > 128, is not supported yet\n",polarParams->K);
   int bit_i,ip;
   int numbytes = polarParams->K>>3;
   int residue = polarParams->K&7;
@@ -327,7 +327,7 @@ void build_polar_tables(t_nrPolar_params *polarParams) {
   AssertFatal(polarParams->N==512 || polarParams->N==256 || polarParams->N==128,"N = %d, not done yet\n",polarParams->N);
   // build G bit vectors for information bit positions and convert the bit as bytes tables in nr_polar_kronecker_power_matrices.c to 64 bit packed vectors.
   // keep only rows of G which correspond to information/crc bits
-  polarParams->G_N_tab = (uint64_t **)malloc(polarParams->K * sizeof(int64_t *));
+  polarParams->G_N_tab = (uint64_t **)malloc((polarParams->K + polarParams->n_pc) * sizeof(int64_t *));
   int k=0;
 
   for (int i=0; i<polarParams->N; i++) {
@@ -412,14 +412,14 @@ void polar_encoder_fast(uint64_t *A,
                         int32_t crcmask,
                         uint8_t ones_flag,
                         t_nrPolar_params *polarParams) {
-  AssertFatal(polarParams->K > 32, "K = %d < 33, is not supported yet\n",polarParams->K);
+  //  AssertFatal(polarParams->K > 32, "K = %d < 33, is not supported yet\n",polarParams->K);
   AssertFatal(polarParams->K < 129, "K = %d > 128, is not supported yet\n",polarParams->K);
   AssertFatal(polarParams->payloadBits < 65, "payload bits = %d > 64, is not supported yet\n",polarParams->payloadBits);
   uint64_t B[4]= {0,0,0,0},Cprime[4]= {0,0,0,0};
   int bitlen = polarParams->payloadBits;
   // append crc
   AssertFatal(bitlen<129,"support for payloads <= 128 bits\n");
-  AssertFatal(polarParams->crcParityBits == 24,"support for 24-bit crc only for now\n");
+  //  AssertFatal(polarParams->crcParityBits == 24,"support for 24-bit crc only for now\n");
   //int bitlen0=bitlen;
   uint64_t tcrc=0;
   uint8_t offset = 0;
@@ -444,7 +444,9 @@ void polar_encoder_fast(uint64_t *A,
     A32_flip[1+offset]=((uint8_t *)&Aprime)[2];
     A32_flip[2+offset]=((uint8_t *)&Aprime)[1];
     A32_flip[3+offset]=((uint8_t *)&Aprime)[0];
-    tcrc = (uint64_t)((crcmask^(crc24c(A32_flip,8*offset+bitlen)>>8)));
+    if      (polarParams->crcParityBits == 24) tcrc = (uint64_t)(((crcmask^(crc24c(A32_flip,8*offset+bitlen)>>8)))&0xffffff);
+    else if (polarParams->crcParityBits == 11) tcrc = (uint64_t)(((crcmask^(crc11(A32_flip,bitlen)>>21)))&0x7ff);
+    else if (polarParams->crcParityBits == 6) tcrc = (uint64_t)(((crcmask^(crc6(A32_flip,bitlen)>>26)))&0x3f);
   } else if (bitlen<=64) {
     uint8_t A64_flip[8+offset];
     if (ones_flag) {
@@ -461,7 +463,8 @@ void polar_encoder_fast(uint64_t *A,
     A64_flip[5+offset]=((uint8_t *)&Aprime)[2];
     A64_flip[6+offset]=((uint8_t *)&Aprime)[1];
     A64_flip[7+offset]=((uint8_t *)&Aprime)[0];
-    tcrc = (uint64_t)((crcmask^(crc24c(A64_flip,8*offset+bitlen)>>8)));
+    if (polarParams->crcParityBits == 24)      tcrc = (uint64_t)((crcmask^(crc24c(A64_flip,8*offset+bitlen)>>8)))&0xffffff;
+    else if (polarParams->crcParityBits == 11) tcrc = (uint64_t)((crcmask^(crc11(A64_flip,bitlen)>>21)))&0x7ff;
   }
   else if (bitlen<=128) {
     uint8_t A128_flip[16+offset];
@@ -479,7 +482,8 @@ void polar_encoder_fast(uint64_t *A,
     A128_flip[10+offset]=((uint8_t*)&Aprime)[5];	  A128_flip[11+offset]=((uint8_t*)&Aprime)[4];
     A128_flip[12+offset]=((uint8_t*)&Aprime)[3];	  A128_flip[13+offset]=((uint8_t*)&Aprime)[2];
     A128_flip[14+offset]=((uint8_t*)&Aprime)[1];	  A128_flip[15+offset]=((uint8_t*)&Aprime)[0];
-    tcrc = (uint64_t)((crcmask^(crc24c(A128_flip,8*offset+bitlen)>>8)));
+    if (polarParams->crcParityBits == 24) tcrc = (uint64_t)((crcmask^(crc24c(A128_flip,8*offset+bitlen)>>8)))&0xffffff;
+    else if (polarParams->crcParityBits == 11) tcrc = (uint64_t)((crcmask^(crc11(A128_flip,bitlen)>>21)))&0x7ff;
   }
 
   int n;
@@ -522,6 +526,7 @@ void polar_encoder_fast(uint64_t *A,
 
 #ifdef DEBUG_POLAR_ENCODER
 
+  printf("Polar encoder: (N,K) : (%d,%d)\n",polarParams->N,polarParams->K);
   if (polarParams->K<65)
     printf("A %llx B %llx Cprime %llx (payload bits %d,crc %x)\n",
            (unsigned long long)(A[0]&(((uint64_t)1<<bitlen)-1)),

openair1/PHY/CODING/nrPolar_tools/nr_polar_uci_defs.h

@@ -33,8 +33,8 @@
 #ifndef __NR_POLAR_UCI_DEFS__H__
 #define __NR_POLAR_UCI_DEFS__H__
 
-#define NR_POLAR_UCI_MESSAGE_TYPE -1 //int8_t
-#define NR_POLAR_UCI_CRC_ERROR_CORRECTION_BITS 3
+#define NR_POLAR_UCI_PUCCH_MESSAGE_TYPE 2 //int8_t
+#define NR_POLAR_PUCCH_CRC_ERROR_CORRECTION_BITS 3
 #define NR_POLAR_PUCCH_PAYLOAD_BITS 32
 #define NR_POLAR_PUCCH_E 32
 

openair1/PHY/CODING/nr_polar_init.c

@@ -87,15 +87,43 @@ static void nr_polar_init(t_nrPolar_params * *polarParams,
       newPolarInitNode->crcCorrectionBits = NR_POLAR_DCI_CRC_ERROR_CORRECTION_BITS;
       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 == -1) { //UCI
+    } 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;
+      
+      if ((messageLength >= 360 && newPolarInitNode->encoderLength >= 1088)||
+	  (messageLength >= 1013)) newPolarInitNode->i_seg = 1;
+
+      newPolarInitNode->crcParityBits = 11;
+      newPolarInitNode->n_pc = 0;
+      newPolarInitNode->n_pc_wm = 0;
+
+      if (messageLength < 20) {
+	newPolarInitNode->crcParityBits = 6;
+	newPolarInitNode->n_pc = 3;
+	if ((newPolarInitNode->encoderLength - messageLength - 6 + 3) < 193) newPolarInitNode->n_pc_wm = 1; 
+      }
+
+
+
+      newPolarInitNode->i_bil = NR_POLAR_PUCCH_I_BIL;
+
+      newPolarInitNode->payloadBits = messageLength;
+      newPolarInitNode->crcCorrectionBits = NR_POLAR_PUCCH_CRC_ERROR_CORRECTION_BITS;
+      //newPolarInitNode->crc_generator_matrix=crc24c_generator_matrix(newPolarInitNode->payloadBits+newPolarInitNode->crcParityBits);//G_P
     } else {
       AssertFatal(1 == 0, "[nr_polar_init] Incorrect Message Type(%d)", messageType);
     }
 
     newPolarInitNode->K = newPolarInitNode->payloadBits + newPolarInitNode->crcParityBits; // Number of bits to encode.
     newPolarInitNode->N = nr_polar_output_length(newPolarInitNode->K,
-    											 newPolarInitNode->encoderLength,
-												 newPolarInitNode->n_max);
+						 newPolarInitNode->encoderLength,
+						 newPolarInitNode->n_max);
     newPolarInitNode->n = log2(newPolarInitNode->N);
     newPolarInitNode->G_N = nr_polar_kronecker_power_matrices(newPolarInitNode->n);
     //polar_encoder vectors: