re-introducing the multi-segment version (for up to 8 segments for now)

openair1/PHY/CODING/TESTBENCH/ldpctest.c

@@ -76,26 +76,30 @@ int test_ldpc(short No_iteration,
   opp_enabled=1;
   cpu_freq_GHz = get_cpu_freq_GHz();
   //short test_input[block_length];
-  unsigned char *test_input;
+  unsigned char *test_input[MAX_NUM_DLSCH_SEGMENTS];
   //short *c; //padded codeword
   short *esimated_output;
-  unsigned char *channel_input;
-  unsigned char *channel_input_optim;
+  unsigned char *channel_input[MAX_NUM_DLSCH_SEGMENTS];
+  unsigned char *channel_input_optim[MAX_NUM_DLSCH_SEGMENTS];
   double *channel_output;
   double *modulated_input;
   short *channel_output_fixed;
-  unsigned int i,trial=0;
+  unsigned int i,j,trial=0;
   short BG,Zc,Kb,nrows,ncols;
   int no_punctured_columns,removed_bit;
   int i1;
   //Table of possible lifting sizes
   short lift_size[51]= {2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,18,20,22,24,26,28,30,32,36,40,44,48,52,56,60,64,72,80,88,96,104,112,120,128,144,160,176,192,208,224,240,256,288,320,352,384};
+  int n_segments=8;
   *errors=0;
   *crc_misses=0;
+
   // generate input block
-  test_input=(unsigned char *)malloc(sizeof(unsigned char) * block_length/8);
-  channel_input = (unsigned char *)malloc(sizeof(unsigned char) * 68*384);
-  channel_input_optim = (unsigned char *)malloc(sizeof(unsigned char) * 68*384);
+  for(j=0;j<MAX_NUM_DLSCH_SEGMENTS;j++) {
+    test_input[j]=(unsigned char *)malloc(sizeof(unsigned char) * block_length/8);
+    channel_input[j] = (unsigned char *)malloc(sizeof(unsigned char) * 68*384);
+    channel_input_optim[j] = (unsigned char *)malloc(sizeof(unsigned char) * 68*384);
+  }
   modulated_input = (double *)malloc(sizeof(double) * 68*384);
   channel_output  = (double *)malloc(sizeof(double) * 68*384);
   reset_meas(&time);
@@ -104,10 +108,12 @@ int test_ldpc(short No_iteration,
   reset_meas(&tprep);
   reset_meas(&tparity);
   reset_meas(&toutput);
-  for (i=0; i<block_length/8; i++)
-  {
-    //test_input[i]=(unsigned char) rand();
-    test_input[i]=217;
+
+  for (j=0;j<MAX_NUM_DLSCH_SEGMENTS;j++) {
+    for (i=0; i<block_length/8; i++) {
+      test_input[j][i]=(unsigned char) rand();
+      //test_input[j][i]=j%256;
+    }
   }
 
   //determine number of bits in codeword
@@ -152,7 +158,7 @@ int test_ldpc(short No_iteration,
   //  printf("puncture:%d\n",no_punctured_columns);
   removed_bit=(nrows-no_punctured_columns-2) * Zc+block_length-(int)(block_length/((float)nom_rate/(float)denom_rate));
   if (ntrials==0)
-    ldpc_encoder_orig(test_input,channel_input, block_length, nom_rate, denom_rate, 1);
+    ldpc_encoder_orig(test_input[0],channel_input[0], block_length, nom_rate, denom_rate, 1);
   
   for (trial=0; trial < ntrials; trial++)
   {
@@ -160,21 +166,24 @@ int test_ldpc(short No_iteration,
     //// encoder
     start_meas(&time);
 
-    //if (BG==1) 
-    //ldpc_encoder(test_input, channel_input,block_length,nom_rate,denom_rate);
-    //else
-    ldpc_encoder_orig(test_input, channel_input,block_length,nom_rate,denom_rate,0);
-    
+    for(j=0;j<n_segments;j++) {
+      //if (BG==1) 
+      //ldpc_encoder(test_input, channel_input,block_length,nom_rate,denom_rate);
+      //else
+      ldpc_encoder_orig(test_input[j], channel_input[j],block_length,nom_rate,denom_rate,0);
+    }
+
     stop_meas(&time);
     start_meas(&time_optim);
-    ldpc_encoder_optim(test_input,channel_input_optim,block_length,nom_rate,denom_rate,&tinput,&tprep,&tparity,&toutput);
+    ldpc_encoder_optim(test_input,channel_input_optim,block_length,nom_rate,denom_rate,n_segments,&tinput,&tprep,&tparity,&toutput);
     stop_meas(&time_optim);
     
     if (ntrials==1)    
-      for (i = 0; i < block_length+(nrows-no_punctured_columns) * Zc - removed_bit; i++)
-	if (channel_input[i]!=channel_input_optim[i]) printf("differ in pos %d (%d,%d)\n",i,
-							     channel_input[i],
-							     channel_input_optim[i]);
+      for (j=0;j<n_segments;j++)
+	for (i = 0; i < block_length+(nrows-no_punctured_columns) * Zc - removed_bit; i++)
+	  if (channel_input[j][i]!=channel_input_optim[j][i]) 
+	    printf("differ in seg %d pos %d (%d,%d)\n",j,i,channel_input[j][i],channel_input_optim[j][i]);
+
     //print_meas_now(&time, "", stdout);
 
    // for (i=0;i<6400;i++)
@@ -197,7 +206,7 @@ int test_ldpc(short No_iteration,
 
 #endif
 
-        if (channel_input[i-2*Zc]==0)
+        if (channel_input[0][i-2*Zc]==0)
           modulated_input[i]=1/sqrt(2);  //QPSK
         else
           modulated_input[i]=-1/sqrt(2);
@@ -225,7 +234,7 @@ int test_ldpc(short No_iteration,
       //count errors
       for (i=2*Zc; i<(Kb+nrows-no_punctured_columns) * Zc-removed_bit; i++)
       {
-        if (esimated_output[i] != channel_input[i-2*Zc])
+        if (esimated_output[i] != channel_input[0][i-2*Zc])
         {
           *errors = (*errors) + 1;
           break;

openair1/PHY/CODING/defs.h

@@ -577,6 +577,6 @@ int encode_parity_check_part_orig(unsigned char *c,unsigned char *d, short BG,sh
 int ldpc_encoder(unsigned char *test_input,unsigned char *channel_input,short block_length, double rate);
 int ldpc_encoder_orig(unsigned char *test_input,unsigned char *channel_input,short block_length,int nom_rate,int denom_rate,unsigned char gen_code);
 int ldpc_encoder_multi_segment(unsigned char **test_input,unsigned char **channel_input,short block_length,double rate,uint8_t n_segments);
-int ldpc_encoder_optim(unsigned char *test_input,unsigned char *channel_input,short block_length,int nom_rate,int denom_rate,time_stats_t *tinput,time_stats_t *tprep,time_stats_t *tparity,time_stats_t *toutput);
+int ldpc_encoder_optim(unsigned char **test_input,unsigned char **channel_input,short block_length,int nom_rate,int denom_rate,int n_segments,time_stats_t *tinput,time_stats_t *tprep,time_stats_t *tparity,time_stats_t *toutput);
 
 #endif

openair1/PHY/CODING/ldpc_encoder2.c

@@ -164,16 +164,19 @@ void encode_parity_check_part_optim(uint8_t *c,uint8_t *d, short BG,short Zc,sho
 
 }
 
-int ldpc_encoder_optim(unsigned char *test_input,unsigned char *channel_input,short block_length,int nom_rate,int denom_rate,time_stats_t *tinput,time_stats_t *tprep,time_stats_t *tparity,time_stats_t *toutput)
+int ldpc_encoder_optim(unsigned char **test_input,unsigned char **channel_input,short block_length,int nom_rate,int denom_rate,int n_segments,time_stats_t *tinput,time_stats_t *tprep,time_stats_t *tparity,time_stats_t *toutput)
 {
 
   short BG,Zc,Kb,nrows,ncols;
-  int i,i1;
+  int i,i1,j;
   int no_punctured_columns,removed_bit;
   //Table of possible lifting sizes
   short lift_size[51]= {2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,18,20,22,24,26,28,30,32,36,40,44,48,52,56,60,64,72,80,88,96,104,112,120,128,144,160,176,192,208,224,240,256,288,320,352,384};
 
   int simd_size;
+  char temp;
+
+  AssertFatal(n_segments>0&&n_segments<=8,"0 < n_segments %d <= 8\n",n_segments);
 
   //determine number of bits in codeword
   if (block_length>3840)
@@ -230,11 +233,13 @@ int ldpc_encoder_optim(unsigned char *test_input,unsigned char *channel_input,sh
   memset(d,0,sizeof(unsigned char) * nrows * Zc);
 
   start_meas(tinput);
-  for (i=0; i<block_length; i++)
-  {
-    //c[i] = test_input[i/8]<<(i%8);
-    //c[i]=c[i]>>7&1;
-    c[i]=(test_input[i/8]&(1<<(i&7)))>>(i&7);
+  for (i=0; i<block_length; i++) {
+    for (j=0; j<n_segments; j++) {
+      temp = (test_input[j][i/8]&(1<<(i&7)))>>(i&7);
+      //printf("c(%d,%d)=%d\n",j,i,temp);
+      c[i] |= (temp << j);
+    }
+    //printf("c[%d]=%d\n",i,c[i]);
   }
   stop_meas(tinput);
 
@@ -269,8 +274,17 @@ int ldpc_encoder_optim(unsigned char *test_input,unsigned char *channel_input,sh
   }
   start_meas(toutput);
   // information part and puncture columns
+  /*
   memcpy(&channel_input[0], &c[2*Zc], (block_length-2*Zc)*sizeof(unsigned char));
   memcpy(&channel_input[block_length-2*Zc], &d[0], ((nrows-no_punctured_columns) * Zc-removed_bit)*sizeof(unsigned char));
+  */
+  for (i=0;i<(block_length-2*Zc);i++) 
+    for (j=0; j<n_segments; j++) 
+      channel_input[j][i] = (c[2*Zc+i]>>j)&1;
+  for (i=0;i<((nrows-no_punctured_columns) * Zc-removed_bit);i++)
+    for (j=0; j<n_segments; j++) 
+      channel_input[j][block_length-2*Zc+i] = (d[i]>>j)&1;
+
   stop_meas(toutput);
   return 0;
 }

openair1/PHY/LTE_TRANSPORT/dlsch_coding.c

@@ -767,6 +767,7 @@ int dlsch_encoding(PHY_VARS_eNB *eNB,
   //  unsigned short m=dlsch->harq_processes[harq_pid]->mcs;
   uint8_t beamforming_mode=0;
   //double rate = 0.33;
+  uint8_t *d_tmp[MAX_NUM_DLSCH_SEGMENTS];
 
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_ENB_DLSCH_ENCODING, VCD_FUNCTION_IN);
 
@@ -830,9 +831,9 @@ int dlsch_encoding(PHY_VARS_eNB *eNB,
 		    &dlsch->harq_processes[harq_pid]->F);
 #endif
 
+#ifdef TD_DECODING
     for (r=0; r<dlsch->harq_processes[harq_pid]->C; r++) {
 
-#ifdef TD_DECODING
       if (r<dlsch->harq_processes[harq_pid]->Cminus)
         Kr = dlsch->harq_processes[harq_pid]->Kminus;
       else
@@ -887,6 +888,14 @@ int dlsch_encoding(PHY_VARS_eNB *eNB,
                                 f1f2mat_old[(iind*2)+1]  // f2 (see 36121-820, page 14)
                                );
       stop_meas(te_stats);
+
+      start_meas(i_stats);
+      dlsch->harq_processes[harq_pid]->RTC[r] =
+        sub_block_interleaving_turbo(4+(Kr_bytes*8),
+                                     &dlsch->harq_processes[harq_pid]->d[r][96],
+                                     dlsch->harq_processes[harq_pid]->w[r]);
+      stop_meas(i_stats);
+    }
 #else
 
     Kr = dlsch->harq_processes[harq_pid]->Kplus;
@@ -898,18 +907,20 @@ int dlsch_encoding(PHY_VARS_eNB *eNB,
     else
     	Kr_int = Kr;
 
+    for (r=0; r<dlsch->harq_processes[harq_pid]->C; r++) {
+      memset(dlsch->harq_processes[harq_pid]->d[r],0,(96+12+3+3*8448)*sizeof(uint8_t));
+      d_tmp[r] = &dlsch->harq_processes[harq_pid]->d[r][96];
 #ifdef DEBUG_DLSCH_CODING
       printf("start ldpc encoder B %d\n",dlsch->harq_processes[harq_pid]->B);
       printf("input %d %d %d %d %d \n", dlsch->harq_processes[harq_pid]->c[r][0], dlsch->harq_processes[harq_pid]->c[r][1], dlsch->harq_processes[harq_pid]->c[r][2],dlsch->harq_processes[harq_pid]->c[r][3], dlsch->harq_processes[harq_pid]->c[r][4]);
 #endif
+    }
 
       start_meas(te_stats);
-      memset(dlsch->harq_processes[harq_pid]->d[r],0,(96+12+3+3*8448)*sizeof(uint8_t));
       //ldpc_encoder((unsigned char*)dlsch->harq_processes[harq_pid]->c[r],(unsigned char*)&dlsch->harq_processes[harq_pid]->d[r][96],Kr,1.0/3.0);
-      ldpc_encoder_optim((unsigned char*)dlsch->harq_processes[harq_pid]->c[r],(unsigned char*)&dlsch->harq_processes[harq_pid]->d[r][96],Kr,1,3,NULL,NULL,NULL,NULL);
+      ldpc_encoder_optim((unsigned char*)dlsch->harq_processes[harq_pid]->c,d_tmp,Kr,1,3,dlsch->harq_processes[harq_pid]->C,NULL,NULL,NULL,NULL);
       stop_meas(te_stats);
 
-#endif
 
 #if 0
       printf("end ldpc encoder -- output\n");
@@ -930,21 +941,14 @@ int dlsch_encoding(PHY_VARS_eNB *eNB,
 #endif
 
       start_meas(i_stats);
-#ifdef TD_DECODING
-      dlsch->harq_processes[harq_pid]->RTC[r] =
-        sub_block_interleaving_turbo(4+(Kr_bytes*8),
-                                     &dlsch->harq_processes[harq_pid]->d[r][96],
-                                     dlsch->harq_processes[harq_pid]->w[r]);
-#else
       for (r=0; r<dlsch->harq_processes[harq_pid]->C; r++) {
 	dlsch->harq_processes[harq_pid]->RTC[r] =
 	  sub_block_interleaving_turbo((Kr_int),
 				       &dlsch->harq_processes[harq_pid]->d[r][96],
 				       dlsch->harq_processes[harq_pid]->w[r]);
       }
-#endif
       stop_meas(i_stats);
-    }
+#endif
 
   }