Merge remote-tracking branch 'origin/bandwidth-testing-pucch' into bandwidth-testing

openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.c

@@ -55,7 +55,6 @@ int32_t nrLDPC_decod(t_nrLDPC_dec_params* p_decParams, int8_t* p_llr, int8_t* p_
     t_nrLDPC_lut* p_lut = &lut;
 
     //printf("p_procBuf->cnProcBuf = %p\n", p_procBuf->cnProcBuf);
-
     // Initialize decoder core(s) with correct LUTs
     numLLR = nrLDPC_init(p_decParams, p_lut);
 
@@ -81,6 +80,7 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
     uint8_t  numMaxIter = p_decParams->numMaxIter;
     e_nrLDPC_outMode outMode = p_decParams->outMode;
 
+    printf("nrLDCP_decoder_core: numMaxIter %d\n",numMaxIter);
     // Minimum number of iterations is 1
     // 0 iterations means hard-decision on input LLRs
     uint32_t i = 1;
@@ -231,7 +231,7 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
 
     // First iteration finished
 
-    while ( (i < (numMaxIter-1)) && (pcRes != 0) )
+    while ( (i < numMaxIter) && (pcRes != 0) )
     {
         // Increase iteration counter
         i++;
@@ -488,5 +488,6 @@ static inline uint32_t nrLDPC_decoder_core(int8_t* p_llr, int8_t* p_out, t_nrLDP
     stop_meas(&p_profiler->llr2bit);
 #endif
 
+    printf("num ldpc iterations %d\n",i);
     return i;
 }

openair1/PHY/CODING/nrPolar_tools/nr_polar_encoder.c

@@ -258,10 +258,11 @@ static inline void polar_rate_matching(const t_nrPolar_params *polarParams,void
   // handle rate matching with a single 128 bit word using bit shuffling
   // can be done with SIMD intrisics if needed
   if (polarParams->groupsize < 8)  {
-    AssertFatal(polarParams->encoderLength<=128,"Need to handle groupsize<8 and N>128\n");
+    AssertFatal(polarParams->encoderLength<=512,"Need to handle groupsize(%d)<8 and N(%d)>512\n",polarParams->groupsize,polarParams->encoderLength);
     uint128_t *out128=(uint128_t*)out;
     uint128_t *in128=(uint128_t*)in;
-    *out128=0;
+    for (int i=0;i<=polarParams->encoderLength>>7;i++)
+      out128[i]=0;
     uint128_t tmp0;
 #ifdef DEBUG_POLAR_ENCODER
     uint128_t tmp1;
@@ -270,15 +271,21 @@ static inline void polar_rate_matching(const t_nrPolar_params *polarParams,void
 #ifdef DEBUG_POLAR_ENCODER
       printf("%d<-%u : %llx.%llx =>",i,polarParams->rate_matching_pattern[i],((uint64_t *)out)[1],((uint64_t *)out)[0]);
 #endif
-      tmp0 = (*in128&(((uint128_t)1)<<polarParams->rate_matching_pattern[i]));
+      uint8_t pi=polarParams->rate_matching_pattern[i];
+      uint8_t pi7=pi>>7;
+      uint8_t pimod128=pi&127;
+      uint8_t imod128=i&127;
+      uint8_t i7=i>>7;
+      
+      tmp0 = (in128[pi7]&(((uint128_t)1)<<(pimod128)));
+      
       if (tmp0!=0) {
-	*out128 = *out128 | ((uint128_t)1)<<i;
+        out128[i7] = out128[i7] | ((uint128_t)1)<<imod128;
 #ifdef DEBUG_POLAR_ENCODER
-	tmp1 = ((uint128_t)1)<<i;
-	printf("%llx.%llx<->%llx.%llx => %llx.%llx\n",
-	       ((uint64_t *)&tmp0)[1],((uint64_t *)&tmp0)[0],
-	       ((uint64_t *)&tmp1)[1],((uint64_t *)&tmp1)[0],
-	       ((uint64_t *)out)[1],((uint64_t *)out)[0]);
+        printf("%llx.%llx<->%llx.%llx => %llx.%llx\n",
+               ((uint64_t *)&tmp0)[1],((uint64_t *)&tmp0)[0],
+               ((uint64_t *)&tmp1)[1],((uint64_t *)&tmp1)[0],
+               ((uint64_t *)out)[1],((uint64_t *)out)[0]);
 #endif
       }
     }

openair1/PHY/NR_TRANSPORT/nr_ulsch_decoding.c

@@ -429,9 +429,10 @@ void nr_processULSegment(void* arg) {
 
   if (check_crc((uint8_t*)llrProcBuf,length_dec,ulsch_harq->F,crc_type)) {
 #ifdef PRINT_CRC_CHECK
-      LOG_I(PHY, "Segment %d CRC OK\n",r);
+      LOG_I(PHY, "Segment %d CRC OK, iterations %d/%d\n",r,no_iteration_ldpc,max_ldpc_iterations);
 #endif
     rdata->decodeIterations = no_iteration_ldpc;
+    if (rdata->decodeIterations > p_decoderParms->numMaxIter) rdata->decodeIterations--;
   } else {
 #ifdef PRINT_CRC_CHECK
       LOG_I(PHY, "CRC NOK\n");

openair1/PHY/NR_TRANSPORT/nr_ulsch_demodulation.c

@@ -1318,8 +1318,8 @@ int nr_rx_pusch(PHY_VARS_gNB *gNB,
       start_meas(&gNB->ulsch_mrc_stats);
       nr_ulsch_detection_mrc(frame_parms,
                              gNB->pusch_vars[ulsch_id]->rxdataF_comp,
-                             gNB->pusch_vars[ulsch_id]->ul_ch_mag,
-                             gNB->pusch_vars[ulsch_id]->ul_ch_magb,
+                             gNB->pusch_vars[ulsch_id]->ul_ch_mag0,
+                             gNB->pusch_vars[ulsch_id]->ul_ch_magb0,
                              symbol,
                              rel15_ul->rb_size);
       stop_meas(&gNB->ulsch_mrc_stats);

openair1/PHY/defs_gNB.h

@@ -808,7 +808,7 @@ typedef struct PHY_VARS_gNB_s {
   /// PUSCH DMRS
   uint32_t ****nr_gold_pusch_dmrs;
 
-  // Mask of occupied RBs
+  // Mask of occupied RBs, per symbol and PRB
   uint32_t rb_mask_ul[14][9];
 
   /// CSI  RS sequence

openair1/SIMULATION/NR_PHY/dlsim.c

@@ -776,9 +776,9 @@ int main(int argc, char **argv)
   AssertFatal((gNB->if_inst         = NR_IF_Module_init(0))!=NULL,"Cannot register interface");
   gNB->if_inst->NR_PHY_config_req      = nr_phy_config_request;
   // common configuration
-  rrc_mac_config_req_gNB(0,0, n_tx, n_tx, 0, scc, 0, 0, NULL);
+  rrc_mac_config_req_gNB(0,0, n_tx, n_tx, scc, NULL, 0, 0, NULL);
   // UE dedicated configuration
-  rrc_mac_config_req_gNB(0,0, n_tx, n_tx, 0, scc, 1, secondaryCellGroup->spCellConfig->reconfigurationWithSync->newUE_Identity,secondaryCellGroup);
+  rrc_mac_config_req_gNB(0,0, n_tx, n_tx, scc, NULL, 1, secondaryCellGroup->spCellConfig->reconfigurationWithSync->newUE_Identity,secondaryCellGroup);
   // reset preprocessor to the one of DLSIM after it has been set during
   // rrc_mac_config_req_gNB
   gNB_mac->pre_processor_dl = nr_dlsim_preprocessor;
@@ -1254,7 +1254,7 @@ int main(int argc, char **argv)
            (float) n_errors / (float) n_trials);
     printf("*****************************************\n");
     printf("\n");
-    dump_pdsch_stats(gNB);
+    dump_pdsch_stats(stdout,gNB);
     printf("SNR %f : n_errors (negative CRC) = %d/%d, Avg round %.2f, Channel BER %e, BLER %.2f, Eff Rate %.4f bits/slot, Eff Throughput %.2f, TBS %u bits/slot\n", SNR, n_errors, n_trials,roundStats[snrRun],berStats[snrRun],blerStats[snrRun],effRate,effRate/TBS*100,TBS);
     printf("\n");
 

openair1/SIMULATION/NR_PHY/ulsim.c

@@ -707,9 +707,9 @@ int main(int argc, char **argv)
 
   gNB->if_inst->NR_PHY_config_req      = nr_phy_config_request;
   // common configuration
-  rrc_mac_config_req_gNB(0,0, n_tx, n_tx, 0, scc, 0, 0, NULL);
+  rrc_mac_config_req_gNB(0,0, n_tx, n_rx, 0, scc, &rrc.carrier.mib,0, 0, NULL);
   // UE dedicated configuration
-  rrc_mac_config_req_gNB(0,0, n_tx, n_tx, 0, scc, 1, secondaryCellGroup->spCellConfig->reconfigurationWithSync->newUE_Identity,secondaryCellGroup);
+  rrc_mac_config_req_gNB(0,0, n_tx, n_rx, 0, scc, &rrc.carrier.mib,1, secondaryCellGroup->spCellConfig->reconfigurationWithSync->newUE_Identity,secondaryCellGroup);
   phy_init_nr_gNB(gNB,0,1);
   N_RB_DL = gNB->frame_parms.N_RB_DL;
 
@@ -752,7 +752,18 @@ int main(int argc, char **argv)
   }
   */
   
-  nr_l2_init_ue(NULL);
+
+
+
+  //Configure UE
+  NR_UE_RRC_INST_t rrcue;
+  memset(&rrcue,0,sizeof(NR_UE_RRC_INST_t));
+  rrc.carrier.MIB = (uint8_t*) malloc(4);
+  rrc.carrier.sizeof_MIB = do_MIB_NR(&rrc,0);
+  rrcue.mib = rrc.carrier.mib.message.choice.mib;
+  rrcue.scell_group_config=secondaryCellGroup;
+  nr_l2_init_ue(&rrcue);
+
   NR_UE_MAC_INST_t* UE_mac = get_mac_inst(0);
   
   UE->if_inst = nr_ue_if_module_init(0);
@@ -763,11 +774,7 @@ int main(int argc, char **argv)
   
   UE_mac->if_module = nr_ue_if_module_init(0);
 
-  //Configure UE
-  rrc.carrier.MIB = (uint8_t*) malloc(4);
-  rrc.carrier.sizeof_MIB = do_MIB_NR(&rrc,0);
-
-  nr_rrc_mac_config_req_ue(0,0,0,rrc.carrier.mib.message.choice.mib, NULL, NULL, secondaryCellGroup);
+//  nr_rrc_mac_config_req_ue(0,0,0,rrc.carrier.mib.message.choice.mib, NULL, NULL, secondaryCellGroup);
 
   nr_ue_phy_config_request(&UE_mac->phy_config);
 
@@ -1267,8 +1274,6 @@ int main(int argc, char **argv)
 	  if(((ulsch_ue[0]->g[i] == 0) && (gNB->pusch_vars[UE_id]->llr[i] <= 0)) ||
 	     ((ulsch_ue[0]->g[i] == 1) && (gNB->pusch_vars[UE_id]->llr[i] >= 0)))
 	    {
-	      /*if(errors_scrambling == 0)
-		printf("\x1B[34m" "[frame %d][trial %d]\t1st bit in error in unscrambling = %d\n" "\x1B[0m", frame, trial, i);*/
 	      errors_scrambling[round]++;
 	    }
 	}
@@ -1276,10 +1281,6 @@ int main(int argc, char **argv)
 
     } // round
     
-    if (n_trials == 1 && errors_scrambling[0] > 0) {
-      printf("\x1B[31m""[frame %d][trial %d]\tnumber of errors in unscrambling = %u\n" "\x1B[0m", frame, trial, errors_scrambling[0]);
-    }
-    
     for (i = 0; i < TBS; i++) {
       
       estimated_output_bit[i] = (ulsch_gNB->harq_processes[harq_pid]->b[i/8] & (1 << (i & 7))) >> (i & 7);
@@ -1294,11 +1295,11 @@ int main(int argc, char **argv)
     if (n_trials == 1) {
       for (int r=0;r<ulsch_ue[0]->harq_processes[harq_pid]->C;r++) 
 	for (int i=0;i<ulsch_ue[0]->harq_processes[harq_pid]->K>>3;i++) {
-	  /*if ((ulsch_ue[0]->harq_processes[harq_pid]->c[r][i]^ulsch_gNB->harq_processes[harq_pid]->c[r][i]) != 0) printf("************");
+	  if ((ulsch_ue[0]->harq_processes[harq_pid]->c[r][i]^ulsch_gNB->harq_processes[harq_pid]->c[r][i]) != 0) printf("************");
 	    printf("r %d: in[%d] %x, out[%d] %x (%x)\n",r,
 	    i,ulsch_ue[0]->harq_processes[harq_pid]->c[r][i],
 	    i,ulsch_gNB->harq_processes[harq_pid]->c[r][i],
-	    ulsch_ue[0]->harq_processes[harq_pid]->c[r][i]^ulsch_gNB->harq_processes[harq_pid]->c[r][i]);*/
+	    ulsch_ue[0]->harq_processes[harq_pid]->c[r][i]^ulsch_gNB->harq_processes[harq_pid]->c[r][i]);
 	}
     }
     if (errors_decoding > 0 && error_flag == 0) {

openair1/SIMULATION/TOOLS/abstraction.c

@@ -39,7 +39,7 @@ double **cos_lut=NULL,* *sin_lut=NULL;
 
 
 
-int init_freq_channel(channel_desc_t *desc,uint16_t nb_rb,int16_t n_samples) {
+int init_freq_channel(channel_desc_t *desc,uint16_t nb_rb,int16_t n_samples,int scs) {
   double delta_f,freq;  // 90 kHz spacing
   double delay;
   int16_t f;
@@ -52,7 +52,7 @@ int init_freq_channel(channel_desc_t *desc,uint16_t nb_rb,int16_t n_samples) {
 
   cos_lut = (double **)malloc(n_samples*sizeof(double *));
   sin_lut = (double **)malloc(n_samples*sizeof(double *));
-  delta_f = nb_rb*180000/(n_samples-1);
+  delta_f = nb_rb*12*scs*1000/(n_samples-1);
 
   for (f=-(n_samples>>1); f<=(n_samples>>1); f++) {
     freq=delta_f*(double)f*1e-6;// due to the fact that delays is in mus
@@ -67,14 +67,14 @@ int init_freq_channel(channel_desc_t *desc,uint16_t nb_rb,int16_t n_samples) {
 
       cos_lut[f+(n_samples>>1)][l] = cos(2*M_PI*freq*delay);
       sin_lut[f+(n_samples>>1)][l] = sin(2*M_PI*freq*delay);
-      //printf("values cos:%d, sin:%d\n", cos_lut[f][l], sin_lut[f][l]);
+      //      printf("values cos:%f, sin:%f\n", cos_lut[f+(n_samples>>1)][l], sin_lut[f+(n_samples>>1)][l]);
     }
   }
 
   return(0);
 }
 
-int freq_channel(channel_desc_t *desc,uint16_t nb_rb,int16_t n_samples) {
+int freq_channel(channel_desc_t *desc,uint16_t nb_rb,int16_t n_samples,int scs) {
   int16_t f,f2,d;
   uint8_t aarx,aatx,l;
   double *clut,*slut;
@@ -95,14 +95,14 @@ int freq_channel(channel_desc_t *desc,uint16_t nb_rb,int16_t n_samples) {
     // if called with n_samples<12*nb_rb+1, we decimate the lut
     n_samples_max=12*nb_rb+1;
 
-    if (init_freq_channel(desc,nb_rb,n_samples_max)==0)
+    if (init_freq_channel(desc,nb_rb,n_samples_max,scs)==0)
       freq_channel_init=1;
     else
       return(-1);
   }
 
   d=(n_samples_max-1)/(n_samples-1);
-  //printf("no_samples=%d, n_samples_max=%d, d=%d\n",n_samples,n_samples_max,d);
+  //  printf("no_samples=%d, n_samples_max=%d, d=%d,nb_taps %d\n",n_samples,n_samples_max,d,desc->nb_taps);
   start_meas(&desc->interp_freq);
 
   for (f=-n_samples_max/2,f2=-n_samples/2; f<n_samples_max/2; f+=d,f2++) {
@@ -111,6 +111,7 @@ int freq_channel(channel_desc_t *desc,uint16_t nb_rb,int16_t n_samples) {
 
     for (aarx=0; aarx<desc->nb_rx; aarx++) {
       for (aatx=0; aatx<desc->nb_tx; aatx++) {
+        AssertFatal(n_samples/2+f2 < (2+(275*12)),"reading past chF %d (n_samples %d, f2 %d)\n",n_samples/2+f2,n_samples,f2);
         desc->chF[aarx+(aatx*desc->nb_rx)][n_samples/2+f2].x=0.0;
         desc->chF[aarx+(aatx*desc->nb_rx)][n_samples/2+f2].y=0.0;
 

openair1/SIMULATION/TOOLS/random_channel.c

@@ -519,12 +519,12 @@ void tdlModel(int  tdl_paths, double *tdl_delays, double *tdl_amps_dB, double DS
     chan_desc->ch[i] = (struct complex *) malloc(chan_desc->channel_length * sizeof(struct complex));
 
   for (int i = 0; i<nb_tx*nb_rx; i++)
-    chan_desc->chF[i] = (struct complex *) malloc(1200 * sizeof(struct complex));
+    chan_desc->chF[i] = (struct complex *) malloc((2+(275*12)) * sizeof(struct complex));
 
   for (int i = 0; i<chan_desc->nb_taps; i++)
     chan_desc->a[i]         = (struct complex *) malloc(nb_tx*nb_rx * sizeof(struct complex));
 
-  chan_desc->R_sqrt  = (struct complex **) malloc(6*sizeof(struct complex **));
+  chan_desc->R_sqrt  = (struct complex **) malloc(tdl_pathsby3*sizeof(struct complex **));
 
   if (nb_tx==2 && nb_rx==2) {
     for (int i = 0; i<(tdl_pathsby3); i++)
@@ -1708,10 +1708,9 @@ void set_channeldesc_name(channel_desc_t *cdesc,char *modelname) {
 int random_channel(channel_desc_t *desc, uint8_t abstraction_flag) {
   double s;
   int i,k,l,aarx,aatx;
-  struct complex anew[NB_ANTENNAS_TX*NB_ANTENNAS_RX],acorr[NB_ANTENNAS_TX*NB_ANTENNAS_RX];
+  struct complex anew[desc->nb_tx*desc->nb_rx],acorr[desc->nb_tx*desc->nb_rx];
   struct complex phase, alpha, beta;
-  AssertFatal(desc->nb_tx<=NB_ANTENNAS_TX && desc->nb_rx <= NB_ANTENNAS_RX,
-              "random_channel.c: Error: temporary buffer for channel not big enough (%d,%d)\n",desc->nb_tx,desc->nb_rx);
+
   start_meas(&desc->random_channel);
 
   for (i=0; i<(int)desc->nb_taps; i++) {

openair1/SIMULATION/TOOLS/sim.h

@@ -477,8 +477,8 @@ int gauss(unsigned int *gauss_LUT,unsigned char Nbits);
 double gaussdouble(double,double);
 void randominit(unsigned int seed_init);
 double uniformrandom(void);
-int freq_channel(channel_desc_t *desc,uint16_t nb_rb, int16_t n_samples);
-int init_freq_channel(channel_desc_t *desc,uint16_t nb_rb,int16_t n_samples);
+int freq_channel(channel_desc_t *desc,uint16_t nb_rb, int16_t n_samples,int scs);
+int init_freq_channel(channel_desc_t *desc,uint16_t nb_rb,int16_t n_samples,int scs);
 uint8_t multipath_channel_nosigconv(channel_desc_t *desc);
 void multipath_tv_channel(channel_desc_t *desc,
                           double **tx_sig_re,

openair2/LAYER2/NR_MAC_UE/config_ue.c

@@ -540,6 +540,7 @@ void config_control_ue(NR_UE_MAC_INST_t *mac){
   NR_BWP_Id_t dl_bwp_id = mac->DL_BWP_Id;
   NR_BWP_Id_t ul_bwp_id = mac->UL_BWP_Id;
   NR_ServingCellConfig_t *scd = mac->cg->spCellConfig->spCellConfigDedicated;
+  if (dl_bwp_id==0) AssertFatal(mac->scc_SIB,"dl_bwp_id 0 (DL %d,UL %d) means mac->scc_SIB should exist here!\n",mac->DL_BWP_Id,mac->UL_BWP_Id);
   NR_BWP_DownlinkCommon_t *bwp_Common = dl_bwp_id>0 ? scd->downlinkBWP_ToAddModList->list.array[dl_bwp_id - 1]->bwp_Common :
                                                       &mac->scc_SIB->downlinkConfigCommon.initialDownlinkBWP;
 
@@ -655,6 +656,9 @@ int nr_rrc_mac_config_req_ue(
     if(scell_group_config != NULL ){
       mac->cg = scell_group_config;
       mac->servCellIndex = *scell_group_config->spCellConfig->servCellIndex;
+      mac->DL_BWP_Id=mac->cg->spCellConfig->spCellConfigDedicated->firstActiveDownlinkBWP_Id ? *mac->cg->spCellConfig->spCellConfigDedicated->firstActiveDownlinkBWP_Id : 0;
+      mac->UL_BWP_Id=mac->cg->spCellConfig->spCellConfigDedicated->uplinkConfig->firstActiveUplinkBWP_Id ? *mac->cg->spCellConfig->spCellConfigDedicated->uplinkConfig->firstActiveUplinkBWP_Id : 0;
+
       config_control_ue(mac);
       if (scell_group_config->spCellConfig->reconfigurationWithSync) {
         if (scell_group_config->spCellConfig->reconfigurationWithSync->rach_ConfigDedicated) {

openair2/LAYER2/nr_rlc/nr_rlc_oai_api.c

@@ -400,15 +400,22 @@ int rlc_module_init(int enb_flag)
 {
   static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
   static int inited = 0;
+  static int inited_ue = 0;
 
   if (pthread_mutex_lock(&lock)) abort();
 
-  if (inited) {
-    LOG_E(RLC, "%s:%d:%s: fatal\n", __FILE__, __LINE__, __FUNCTION__);
+  if (enb_flag == 1 && inited) {
+    LOG_E(RLC, "%s:%d:%s: fatal, inited already 1\n", __FILE__, __LINE__, __FUNCTION__);
+    exit(1);
+  }
+
+  if (enb_flag == 0 && inited_ue) {
+    LOG_E(RLC, "%s:%d:%s: fatal, inited_ue already 1\n", __FILE__, __LINE__, __FUNCTION__);
     exit(1);
   }
 
-  inited = 1;
+  if (enb_flag == 1) inited = 1;
+  if (enb_flag == 0) inited_ue = 1;
 
   nr_rlc_ue_manager = new_nr_rlc_ue_manager(enb_flag);