16-bit integer optimization, reduced memcpy after list sorting

openair1/PHY/CODING/TESTBENCH/polartest.c

@@ -18,6 +18,7 @@ int main(int argc, char *argv[]) {
 	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);
@@ -30,7 +31,7 @@ int main(int argc, char *argv[]) {
 	reset_meas(&path_metric);
 	reset_meas(&update_LLR);
 
-	randominit(0);
+	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
@@ -43,7 +44,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:h")) != -1)
+	while ((arguments = getopt (argc, argv, "s:d:f:m:i:l:a:h:q")) != -1)
 	switch (arguments)
 	{
 		case 's':
@@ -75,6 +76,10 @@ int main(int argc, char *argv[]) {
 			pathMetricAppr = (uint8_t) atoi(optarg);
 			break;
 
+  	        case 'q':
+		        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);
@@ -131,6 +136,7 @@ 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;
@@ -159,12 +165,19 @@ 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] > 1024) channelOutput_int8[i] = 32768;
+			  else if (channelOutput[i] < -1023) channelOutput_int8[i] = -32767;
+			  else channelOutput_int8[i] = (int16_t) (32*channelOutput[i]);
+			}
 		}
 
 
 		start_meas(&timeDecoder);
-		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);
-																	       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(channelOutput_int8, estimatedOutput, &nrPolar_params, decoderListSize, &polar_decoder_init,&polar_rate_matching,&decoding,&bit_extraction,&deinterleaving,&sorting,&path_metric,&update_LLR);	
+		stop_meas(&timeDecoder); 
 
 		//calculate errors
 		if (decoderState==-1) {
@@ -207,9 +220,9 @@ int main(int argc, char *argv[]) {
 		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*deinterleaving.trials));
-		printf("decoding sorting %9.3fus\n",sorting.diff/(cpu_freq_GHz*1000.0*deinterleaving.trials));
-		printf("decoding updateLLR %9.3fus\n",update_LLR.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_tools/nr_polar_defs.h

@@ -104,6 +104,9 @@ void nr_polar_rate_matching_pattern(uint16_t *rmp, uint16_t *J, const uint8_t *P
 void nr_polar_rate_matching(double *input, double *output, uint16_t *rmp,
 		uint16_t K, uint16_t N, uint16_t E);
 
+void nr_polar_rate_matching_int8(int16_t *input, int16_t *output, uint16_t *rmp, 
+				 uint16_t K, uint16_t N, uint16_t E);
+
 void nr_polar_interleaving_pattern(uint16_t K, uint8_t I_IL, uint16_t *PI_k_);
 
 void nr_polar_info_bit_pattern(uint8_t *ibp, int16_t *Q_I_N, int16_t *Q_F_N,
@@ -138,31 +141,57 @@ typedef struct decoder_list_s {
   uint8_t bit[1+nmax][Nmax];
   double llr[1+nmax][Nmax]; 
   uint8_t crcChecksum[24]; 
-  uint8_t crcState; 
   double pathMetric; 
 
 } decoder_list_t;
 
+typedef struct decoder_list_int8_s {
+  
+  uint8_t bit[1+nmax][Nmax];
+  int16_t llr[1+nmax][Nmax]; 
+  uint8_t crcChecksum[24]; 
+  int32_t pathMetric; 
+
+} decoder_list_int8_t;
+
 void updateLLR(decoder_list_t **dlist,uint8_t **llrU, uint8_t **bitU,
 	       uint8_t listSize, uint16_t row, uint16_t col, uint16_t xlen, uint8_t ylen, uint8_t approximation);
 
+void updateLLR_int8(decoder_list_int8_t **dlist,uint8_t **llrU, uint8_t **bitU,
+	       uint8_t listSize, uint16_t row, uint16_t col, uint16_t xlen, uint8_t ylen);
+
 void updateBit(decoder_list_t **dlist, uint8_t **bitU, uint8_t listSize, uint16_t row,
 	       uint16_t col, uint16_t xlen, uint8_t ylen);
 
+void updateBit_int8(decoder_list_int8_t **dlist, uint8_t **bitU, uint8_t listSize, uint16_t row,
+		    uint16_t col, uint16_t xlen, uint8_t ylen);
+
 void updatePathMetric(decoder_list_t **dlist,uint8_t listSize, uint8_t bitValue,
-		      uint16_t row, uint8_t approximation);
+		       uint16_t row, uint8_t approximation);
+
+void updatePathMetric0_int8(decoder_list_int8_t **dlist,uint8_t listSize, uint16_t row);
 
 void updatePathMetric2(decoder_list_t **dlist, uint8_t listSize, uint16_t row, uint8_t appr);
 
+void updatePathMetric2_int8(decoder_list_int8_t **dlist, uint8_t listSize, uint16_t row);
+
 void updateCrcChecksum(decoder_list_t **dlist, uint8_t **crcGen,
 		       uint8_t listSize, uint32_t i2, uint8_t len);
 
+void updateCrcChecksum_int8(decoder_list_int8_t **dlist, uint8_t **crcGen,
+			    uint8_t listSize, uint32_t i2, uint8_t len);
+
 void updateCrcChecksum2(decoder_list_t **dlist, uint8_t **crcGen,
 			uint8_t listSize, uint32_t i2, uint8_t len);
 
+void updateCrcChecksum2_int8(decoder_list_int8_t **dlist, uint8_t **crcGen,
+			     uint8_t listSize, uint32_t i2, uint8_t len);
+
 
 void nr_sort_asc_double_1D_array_ind(double *matrix, int *ind, int len);
 
+void nr_sort_asc_int16_1D_array_ind(int32_t *matrix, int *ind, int len);
+
 uint8_t **crc24c_generator_matrix(uint16_t payloadSizeBits);
 uint8_t **crc11_generator_matrix(uint16_t payloadSizeBits);
 uint8_t **crc6_generator_matrix(uint16_t payloadSizeBits);

openair1/PHY/CODING/nrPolar_tools/nr_polar_matrix_and_array.c

@@ -168,3 +168,28 @@ void nr_sort_asc_double_1D_array_ind(double *matrix, int *ind, int 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];
+		}
+	}
+
+}