Merge remote-tracking branch 'origin/polar-decoder-optimizations' into nr_pbchsim

cmake_targets/CMakeLists.txt

@@ -1125,6 +1125,7 @@ set(PHY_POLARSRC
   ${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/decoder_K56_N512_E864.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

openair1/PHY/CODING/TESTBENCH/polartest.c

@@ -15,12 +15,23 @@ int main(int argc, char *argv[]) {
 
 	//Initiate timing. (Results depend on CPU Frequency. Therefore, might change due to performance variances during simulation.)
 	time_stats_t timeEncoder,timeDecoder;
+	time_stats_t polar_decoder_init,polar_rate_matching,decoding,bit_extraction,deinterleaving;
+	time_stats_t path_metric,sorting,update_LLR;
 	opp_enabled=1;
+	int decoder_int8=0;
 	cpu_freq_GHz = get_cpu_freq_GHz();
 	reset_meas(&timeEncoder);
 	reset_meas(&timeDecoder);
-
-	randominit(0);
+	reset_meas(&polar_decoder_init);
+	reset_meas(&polar_rate_matching);
+	reset_meas(&decoding);
+	reset_meas(&bit_extraction);
+	reset_meas(&deinterleaving);
+	reset_meas(&sorting);
+	reset_meas(&path_metric);
+	reset_meas(&update_LLR);
+
+	randominit(1234);
 	//Default simulation values (Aim for iterations = 1000000.)
 	int itr, iterations = 1000, arguments, polarMessageType = 1; //0=DCI, 1=PBCH, 2=UCI
 	double SNRstart = -20.0, SNRstop = 0.0, SNRinc= 0.5; //dB
@@ -32,8 +43,9 @@ int main(int argc, char *argv[]) {
 	double timeEncoderCumulative = 0, timeDecoderCumulative = 0;
 
 	uint8_t decoderListSize = 8, pathMetricAppr = 0; //0 --> eq. (8a) and (11b), 1 --> eq. (9) and (12)
+	int generate_optim_code=0;
 
-	while ((arguments = getopt (argc, argv, "s:d:f:m:i:l:a:h")) != -1)
+	while ((arguments = getopt (argc, argv, "s:d:f:m:i:l:a:h:qg")) != -1)
 	switch (arguments)
 	{
 		case 's':
@@ -65,6 +77,17 @@ int main(int argc, char *argv[]) {
 			pathMetricAppr = (uint8_t) atoi(optarg);
 			break;
 
+  	        case 'q':
+		        decoder_int8=1;
+		        break;
+
+    	        case 'g':
+		  generate_optim_code=1;
+                  iterations=1;
+		  SNRstart=-6.0;
+		  SNRstop =-6.0;
+		  decoder_int8=1;
+                  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);
@@ -121,16 +144,23 @@ int main(int argc, char *argv[]) {
 	double *modulatedInput = malloc (sizeof(double) * coderLength); //channel input
 
 	double *channelOutput  = malloc (sizeof(double) * coderLength); //add noise
+	int16_t *channelOutput_int8  = malloc (sizeof(int16_t) * coderLength); //add noise
 	uint8_t *estimatedOutput = malloc(sizeof(uint8_t) * testLength); //decoder output
 
 	t_nrPolar_params nrPolar_params;
 	nr_polar_init(&nrPolar_params, polarMessageType);
+	nr_polar_llrtableinit();
+
+	if (generate_optim_code==1) nrPolar_params.decoder_kernel = NULL;
 
 	// We assume no a priori knowledge available about the payload.
 	double aPrioriArray[nrPolar_params.payloadBits];
-	for (int i=0; i<nrPolar_params.payloadBits; i++) aPrioriArray[i] = NAN;
+	for (int i=0; i<=nrPolar_params.payloadBits; i++) aPrioriArray[i] = NAN;
+
+	printf("SNRstart %f, SNRstop %f,, SNRinc %f\n",SNRstart,SNRstop,SNRinc);
 
 	for (SNR = SNRstart; SNR <= SNRstop; SNR += SNRinc) {
+	  printf("SNR %f\n",SNR);
 		SNR_lin = pow(10, SNR/10);
 		for (itr = 1; itr <= iterations; itr++) {
 
@@ -149,13 +179,29 @@ int main(int argc, char *argv[]) {
 				modulatedInput[i]=(-1)/sqrt(2);
 
 			channelOutput[i] = modulatedInput[i] + (gaussdouble(0.0,1.0) * (1/sqrt(2*SNR_lin)));
+
+			if (decoder_int8==1) {
+			  if (channelOutput[i] > 15) channelOutput_int8[i] = 127;
+			  else if (channelOutput[i] < -16) channelOutput_int8[i] = -128;
+			  else channelOutput_int8[i] = (int16_t) (8*channelOutput[i]);
+			}
 		}
 
 
 		start_meas(&timeDecoder);
-		decoderState = polar_decoder(channelOutput, estimatedOutput, &nrPolar_params, decoderListSize, aPrioriArray, pathMetricAppr);
-		stop_meas(&timeDecoder);
-
+		if (decoder_int8==0) 
+		  decoderState = polar_decoder(channelOutput, estimatedOutput, &nrPolar_params, 
+					       decoderListSize, aPrioriArray, pathMetricAppr,
+					       &polar_decoder_init,&polar_rate_matching,&decoding,
+					       &bit_extraction,&deinterleaving,&sorting,&path_metric,&update_LLR);
+		else
+		  decoderState = polar_decoder_int8_new(channelOutput_int8, estimatedOutput, &nrPolar_params, 
+							decoderListSize, &polar_decoder_init,&polar_rate_matching,
+							&decoding,&bit_extraction,&deinterleaving,
+							&sorting,&path_metric,&update_LLR,
+							generate_optim_code);	
+		stop_meas(&timeDecoder); 
+		
 		//calculate errors
 		if (decoderState==-1) {
 			blockErrorState=-1;
@@ -191,7 +237,15 @@ int main(int argc, char *argv[]) {
 				decoderListSize, pathMetricAppr, SNR, ((double)blockErrorCumulative/iterations),
 				((double)bitErrorCumulative / (iterations*testLength)),
 				(timeEncoderCumulative/iterations),timeDecoderCumulative/iterations);
-
+		printf("decoding init %9.3fus\n",polar_decoder_init.diff/(cpu_freq_GHz*1000.0*polar_decoder_init.trials));
+
+		printf("decoding polar_rate_matching %9.3fus\n",polar_rate_matching.diff/(cpu_freq_GHz*1000.0*polar_rate_matching.trials));
+		printf("decoding decoding %9.3fus\n",decoding.diff/(cpu_freq_GHz*1000.0*decoding.trials));
+		printf("decoding bit_extraction %9.3fus\n",bit_extraction.diff/(cpu_freq_GHz*1000.0*bit_extraction.trials));
+		printf("decoding deinterleaving %9.3fus\n",deinterleaving.diff/(cpu_freq_GHz*1000.0*deinterleaving.trials));
+		printf("decoding path_metric %9.3fus\n",path_metric.diff/(cpu_freq_GHz*1000.0*decoding.trials));
+		printf("decoding sorting %9.3fus\n",sorting.diff/(cpu_freq_GHz*1000.0*decoding.trials));
+		printf("decoding updateLLR %9.3fus\n",update_LLR.diff/(cpu_freq_GHz*1000.0*decoding.trials));
 		blockErrorCumulative = 0; bitErrorCumulative = 0;
 		timeEncoderCumulative = 0; timeDecoderCumulative = 0;
 	}

openair1/PHY/CODING/nrPolar_init.c

@@ -27,9 +27,9 @@ 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 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
@@ -62,6 +62,11 @@ uint32_t poly24c = 0xB2B11700; //101100101011000100010111 -> D^24...
 		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->decoder_kernel = NULL;//polar_decoder_K56_N512_E864;
+
+
+
 	} 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
@@ -131,6 +136,7 @@ uint32_t poly24c = 0xB2B11700; //101100101011000100010111 -> D^24...
                 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;
@@ -161,5 +167,38 @@ uint32_t poly24c = 0xB2B11700; //101100101011000100010111 -> D^24...
 	nr_polar_channel_interleaver_pattern(polarParams->channel_interleaver_pattern,
 			polarParams->i_bil, polarParams->encoderLength);
 
+	polarParams->extended_crc_generator_matrix = malloc(polarParams->K * sizeof(uint8_t *)); //G_P3
+	uint8_t tempECGM[polarParams->K][polarParams->crcParityBits];
+	for (int i = 0; i < polarParams->K; i++){
+	  polarParams->extended_crc_generator_matrix[i] = malloc(polarParams->crcParityBits * sizeof(uint8_t));
+	}
+	
+	for (int i=0; i<polarParams->payloadBits; i++) {
+	  for (int j=0; j<polarParams->crcParityBits; j++) {
+	    tempECGM[i][j]=polarParams->crc_generator_matrix[i][j];
+	  }
+	}
+	for (int i=polarParams->payloadBits; i<polarParams->K; i++) {
+	  for (int j=0; j<polarParams->crcParityBits; j++) {
+	    if( (i-polarParams->payloadBits) == j ){
+	      tempECGM[i][j]=1;
+	    } else {
+	      tempECGM[i][j]=0;
+	    }
+	  }
+	}
+	
+	for (int i=0; i<polarParams->K; i++) {
+	  for (int j=0; j<polarParams->crcParityBits; j++) {
+	    polarParams->extended_crc_generator_matrix[i][j]=tempECGM[polarParams->interleaving_pattern[i]][j];
+	  }
+	}
+
+
+	build_decoder_tree(polarParams);
+	printf("decoder tree nodes %d\n",polarParams->tree.num_nodes);
+	
+
+	
 	free(J);
 }

openair1/PHY/CODING/nrPolar_tools/nr_polar_matrix_and_array.c

@@ -66,38 +66,30 @@ uint8_t ***nr_alloc_uint8_t_3D_array(uint16_t xlen, uint16_t ylen, uint16_t zlen
 	return output;
 }
 
-double ***nr_alloc_double_3D_array(uint16_t xlen, uint16_t ylen, uint16_t zlen) {
-	double ***output;
-	int i, j;
-
-	if ((output = malloc(xlen * sizeof(*output))) == NULL) {
-		perror("[nr_alloc_double_3D_array] Problem at 1D allocation");
-		return NULL;
-	}
-	for (i = 0; i < xlen; i++)
-		output[i] = NULL;
-
-
-	for (i = 0; i < xlen; i++)
-		if ((output[i] = malloc(ylen * sizeof *output[i])) == NULL) {
-			perror("[nr_alloc_double_3D_array] Problem at 2D allocation");
-			nr_free_double_3D_array(output, xlen, ylen);
-			return NULL;
-		}
-	for (i = 0; i < xlen; i++)
-		for (j = 0; j < ylen; j++)
-			output[i][j] = NULL;
-
-
-	for (i = 0; i < xlen; i++)
-		for (j = 0; j < ylen; j++)
-			if ((output[i][j] = malloc(zlen * sizeof *output[i][j])) == NULL) {
-				perror("[nr_alloc_double_3D_array] Problem at 3D allocation");
-				nr_free_double_3D_array(output, xlen, ylen);
-				return NULL;
-			}
-
-	return output;
+double **nr_alloc_double_2D_array(uint16_t xlen, uint16_t ylen) {
+  double **output;
+  int i, j;
+  
+  if ((output = malloc(xlen * sizeof(*output))) == NULL) {
+    perror("[nr_alloc_double_3D_array] Problem at 1D allocation");
+    return NULL;
+  }
+  for (i = 0; i < xlen; i++)
+    output[i] = NULL;
+  
+  
+  for (i = 0; i < xlen; i++)
+    if ((output[i] = malloc(ylen * sizeof *output[i])) == NULL) {
+      perror("[nr_alloc_double_2D_array] Problem at 2D allocation");
+      nr_free_double_2D_array(output, xlen);
+      return NULL;
+    }
+  for (i = 0; i < xlen; i++)
+    for (j = 0; j < ylen; j++)
+      output[i][j] = 0;
+  
+
+  return output;
 }
 
 uint8_t **nr_alloc_uint8_t_2D_array(uint16_t xlen, uint16_t ylen) {
@@ -138,31 +130,28 @@ void nr_free_uint8_t_3D_array(uint8_t ***input, uint16_t xlen, uint16_t ylen) {
 }
 
 void nr_free_uint8_t_2D_array(uint8_t **input, uint16_t xlen) {
-	for (int i = 0; i < xlen; i++) free(input[i]);
-	free(input);
+  for (int i = 0; i < xlen; i++) free(input[i]);
+  free(input);
 }
 
-void nr_free_double_3D_array(double ***input, uint16_t xlen, uint16_t ylen) {
-	int i, j;
-
-	for (i = 0; i < xlen; i++) {
-		for (j = 0; j < ylen; j++) {
-			free(input[i][j]);
-		}
-		free(input[i]);
-	}
-	free(input);
+void nr_free_double_2D_array(double **input, uint16_t xlen) {
+  int i;
+  
+  for (i = 0; i < xlen; i++) {
+    free(input[i]);
+  }
+  free(input);
 }
 
 // Modified Bubble Sort.
-void nr_sort_asc_double_1D_array_ind(double *matrix, uint8_t *ind, uint8_t len) {
-	uint8_t swaps;
+void nr_sort_asc_double_1D_array_ind(double *matrix, int *ind, int len) {
+	int swaps;
 	double temp;
-	uint8_t tempInd;
+	int tempInd;
 
-	for (uint8_t i = 0; i < len; i++) {
+	for (int i = 0; i < len; i++) {
 		swaps = 0;
-		for (uint8_t j = 0; j < (len - i) - 1; j++) {
+		for (int j = 0; j < (len - i) - 1; j++) {
 			if (matrix[j] > matrix[j + 1]) {
 				temp = matrix[j];
 				matrix[j] = matrix[j + 1];
@@ -179,3 +168,28 @@ void nr_sort_asc_double_1D_array_ind(double *matrix, uint8_t *ind, uint8_t len)
 			break;
 	}
 }
+
+void nr_sort_asc_int16_1D_array_ind(int32_t *matrix, int *ind, int len) {
+  int swaps;
+  int16_t temp;
+  int tempInd;
+  
+  for (int i = 0; i < len; i++) {
+    swaps = 0;
+    for (int j = 0; j < (len - i) - 1; j++) {
+      if (matrix[j] > matrix[j + 1]) {
+	temp = matrix[j];
+	matrix[j] = matrix[j + 1];
+	matrix[j + 1] = temp;
+	
+	tempInd = ind[j];
+	ind[j] = ind[j + 1];
+	ind[j + 1] = tempInd;
+	
+	swaps++;
+      }
+    }
+    if (swaps == 0)
+      break;
+  }
+}

openair1/PHY/CODING/nrPolar_tools/nr_polar_rate_match.c

@@ -79,3 +79,24 @@ void nr_polar_rate_matching(double *input, double *output, uint16_t *rmp, uint16
 	}
 
 }
+
+void nr_polar_rate_matching_int8(int16_t *input, int16_t *output, uint16_t *rmp, uint16_t K, uint16_t N, uint16_t E){
+
+	if (E>=N) { //repetition
+		for (int i=0; i<=N-1; i++) output[i]=0;
+		for (int i=0; i<=E-1; i++){
+			output[rmp[i]]+=input[i];
+		}
+	} else {
+		if ( (K/(double)E) <= (7.0/16) ) { //puncturing
+			for (int i=0; i<=N-1; i++) output[i]=0;
+		} else { //shortening
+			for (int i=0; i<=N-1; i++) output[i]=INFINITY;
+		}
+
+		for (int i=0; i<=E-1; i++){
+			output[rmp[i]]=input[i];
+		}
+	}
+
+}

openair1/PHY/NR_TRANSPORT/nr_pbch.c

@@ -220,7 +220,7 @@ int nr_generate_pbch(NR_gNB_PBCH *pbch,
   uint8_t nushift;
   uint8_t *xbyte = pbch->pbch_a;
   memset((void*) xbyte, 0, 1);
-  uint8_t pbch_a_b[32];
+  //uint8_t pbch_a_b[32];
 
   LOG_I(PHY, "PBCH generation started\n");
 
@@ -283,10 +283,10 @@ int nr_generate_pbch(NR_gNB_PBCH *pbch,
     printf("pbch_a_prime[%d]: 0x%02x\n", i, pbch->pbch_a_prime[i]);
 #endif
 
-for (int m=0;m<32;m++){
-pbch_a_b[m] = ((pbch->pbch_a_prime[m/8]>>(m&7))&01);
+//for (int m=0;m<32;m++){
+//pbch_a_b[m] = ((pbch->pbch_a_prime[m/8]>>(m&7))&01);
 //printf("pbch_a_b[%d] %d\n", m, pbch_a_b[m] );
-}
+//}
 
   /// CRC, coding and rate matching
   polar_encoder (pbch->pbch_a_prime, pbch->pbch_e, &frame_parms->pbch_polar_params);

openair1/SCHED_NR/nr_ru_procedures.c

@@ -101,8 +101,7 @@ void nr_feptx_ofdm_2thread(RU_t *ru) {
   // this copy should be done in the precoding thread (currently inactive)
   for (int aa=0;aa<ru->nb_tx;aa++)
   memcpy((void*)ru->common.txdataF_BF[aa],
-   (void*)&ru->gNB_list[0]->common_vars.txdataF[aa][subframe*fp->samples_per_subframe_wCP],
-   fp->samples_per_subframe_wCP*sizeof(int32_t));
+   (void*)ru->gNB_list[0]->common_vars.txdataF[aa], fp->samples_per_subframe_wCP*sizeof(int32_t));
 
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_RU_FEPTX_OFDM , 1 );
 

openair1/SCHED_NR/phy_procedures_nr_gNB.c

@@ -170,8 +170,7 @@ void phy_procedures_gNB_TX(PHY_VARS_gNB *gNB,
 
   // clear the transmit data array for the current subframe
   for (aa=0; aa<cfg->rf_config.tx_antenna_ports.value; aa++) {      
-    memset(&gNB->common_vars.txdataF[aa][subframe*fp->samples_per_subframe_wCP],
-	   0,fp->samples_per_subframe_wCP*sizeof(int32_t));
+    memset(gNB->common_vars.txdataF[aa],0,fp->samples_per_subframe_wCP*sizeof(int32_t));
   }
 
   if (nfapi_mode == 0 || nfapi_mode == 1) {