Reduce buffer size of rxdataF_comp

nr_channel_estimation() produces combined output of all antenna ports for each layer. So reduced the buffer size from no. of layer times no. of antennas to no. of layers.
Signed-off-by: Rupanjali <rupanjali.srivastava@openairinterface.org>

openair1/PHY/INIT/nr_init.c

@@ -176,14 +176,14 @@ void phy_init_nr_gNB(PHY_VARS_gNB *gNB)
     NR_gNB_PUSCH *pusch = &gNB->pusch_vars[ULSCH_id];
     pusch->ul_ch_estimates = (int32_t **)malloc16(n_buf * sizeof(int32_t *));
     pusch->ptrs_phase_per_slot = (int32_t **)malloc16(n_buf * sizeof(int32_t *));
-    pusch->rxdataF_comp = (c16_t **)malloc16(n_buf * sizeof(*pusch->rxdataF_comp));
     for (int i = 0; i < n_buf; i++) {
       pusch->ul_ch_estimates[i] = (int32_t *)malloc16_clear(sizeof(int32_t) * fp->ofdm_symbol_size * fp->symbols_per_slot);
       pusch->ptrs_phase_per_slot[i] = (int32_t *)malloc16_clear(sizeof(int32_t) * fp->symbols_per_slot); // symbols per slot
-      pusch->rxdataF_comp[i] = (c16_t *)malloc16_clear(sizeof(**pusch->rxdataF_comp) * nb_re_pusch2 * fp->symbols_per_slot);
     }
 
+    pusch->rxdataF_comp = (c16_t **)malloc16(max_ul_mimo_layers * sizeof(*pusch->rxdataF_comp));
     for (int i = 0; i < max_ul_mimo_layers; i++) {
+      pusch->rxdataF_comp[i] = (c16_t *)malloc16_clear(sizeof(**pusch->rxdataF_comp) * nb_re_pusch2 * fp->symbols_per_slot);
     }
     pusch->llr = (int16_t *)malloc16_clear((8 * ((3 * 8 * 6144) + 12))
                                            * sizeof(int16_t)); // [hna] 6144 is LTE and (8*((3*8*6144)+12)) is not clear
@@ -232,8 +232,10 @@ void phy_free_nr_gNB(PHY_VARS_gNB *gNB)
     for (int i = 0; i < n_buf; i++) {
       free_and_zero(pusch_vars->ul_ch_estimates[i]);
       free_and_zero(pusch_vars->ptrs_phase_per_slot[i]);
-      free_and_zero(pusch_vars->rxdataF_comp[i]);
     }
+    for (int i = 0; i < max_ul_mimo_layers; i++)
+      free_and_zero(pusch_vars->rxdataF_comp[i]);
+
     free_and_zero(pusch_vars->ul_ch_estimates);
     free_and_zero(pusch_vars->ptrs_phase_per_slot);
     free_and_zero(pusch_vars->ul_valid_re_per_slot);

openair1/PHY/NR_TRANSPORT/nr_ulsch_demodulation.c

@@ -244,7 +244,7 @@ static void inner_rx(PHY_VARS_gNB *gNB,
 
   memset(rho, 0, sizeof(rho));
   for (int i = 0; i < nb_layer; i++)
-    memset(&pusch_vars->rxdataF_comp[i*nb_rx_ant][symbol * buffer_length], 0, sizeof(int32_t) * buffer_length);
+    memset(&pusch_vars->rxdataF_comp[i][symbol * buffer_length], 0, sizeof(int32_t) * buffer_length);
 
   nr_channel_compensation(buffer_length,
                           nb_rx_ant,
@@ -286,7 +286,7 @@ static void inner_rx(PHY_VARS_gNB *gNB,
   if (nb_layer == 2) {
     if (rel15_ul->qam_mod_order <= 6) {
       nr_compute_ML_llr((c16_t *)&pusch_vars->rxdataF_comp[0][symbol * buffer_length],
-                        (c16_t *)&pusch_vars->rxdataF_comp[nb_rx_ant][symbol * buffer_length],
+                        (c16_t *)&pusch_vars->rxdataF_comp[1][symbol * buffer_length],
                         rxF_ch_maga[0],
                         rxF_ch_maga[1],
                         llr[0],
@@ -315,7 +315,7 @@ static void inner_rx(PHY_VARS_gNB *gNB,
   }
   if (nb_layer != 2 || rel15_ul->qam_mod_order > 6)
     for (int aatx = 0; aatx < nb_layer; aatx++)
-      nr_compute_llr(&pusch_vars->rxdataF_comp[aatx * nb_rx_ant][symbol * buffer_length],
+      nr_compute_llr(&pusch_vars->rxdataF_comp[aatx][symbol * buffer_length],
                      rxF_ch_maga[aatx],
                      rxF_ch_magb[aatx],
                      rxF_ch_magc[aatx],

openair1/PHY/NR_UE_ESTIMATION/nr_dl_channel_estimation.c

@@ -1345,7 +1345,7 @@ void nr_pdsch_ptrs_processing(int nbRx,
                               int32_t ptrs_re_per_slot[][14],
                               uint32_t rx_size_symbol,
                               int nl,
-                              c16_t rxdataF_comp[][nl * nbRx][rx_size_symbol],
+                              c16_t rxdataF_comp[][nl][rx_size_symbol],
                               NR_DL_FRAME_PARMS *frame_parms,
                               fapi_nr_dl_config_dlsch_pdu_rel15_t *dlsch_config,
                               uint8_t nr_slot_rx,

openair1/PHY/NR_UE_ESTIMATION/nr_estimation.h

@@ -119,7 +119,7 @@ void nr_pdsch_ptrs_processing(int nbRx,
                               int32_t ptrs_re_per_slot[][14],
                               uint32_t rx_size_symbol,
                               int nl,
-                              c16_t rxdataF_comp[][nl * nbRx][rx_size_symbol],
+                              c16_t rxdataF_comp[][nl][rx_size_symbol],
                               NR_DL_FRAME_PARMS *frame_parms,
                               fapi_nr_dl_config_dlsch_pdu_rel15_t *dlsch_config,
                               uint8_t nr_slot_rx,

openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_demodulation.c

@@ -524,7 +524,7 @@ void nr_conjch0_mult_ch1(c16_t *ch0, c16_t *ch1, c16_t *ch0conj_ch1, unsigned sh
 static void nr_dlsch_mmse(uint32_t rx_size_symbol,
                           unsigned char n_rx,
                           unsigned char nl, // number of layer
-                          c16_t rxdataF_comp[][nl * n_rx][rx_size_symbol],
+                          c16_t rxdataF_comp[][nl][rx_size_symbol],
                           c16_t dl_ch_mag[][rx_size_symbol],
                           c16_t dl_ch_magb[][rx_size_symbol],
                           c16_t dl_ch_magr[][rx_size_symbol],
@@ -607,7 +607,7 @@ static void nr_dlsch_mmse(uint32_t rx_size_symbol,
       // print_shorts(" H_h_H=",(int16_t*)&conjH_H_elements[ctx*nl+rtx][0][0]);
       // print_shorts(" Inv_H_h_H=",(int16_t*)&inv_H_h_H[ctx*nl+rtx][0]);
       mult_complex_vectors(inv_H_h_H[ctx][rtx],
-                           rxdataF_comp[symbol][ctx * n_rx],
+                           rxdataF_comp[symbol][ctx],
                            outtemp,
                            sizeofArray(outtemp),
                            shift - (fp_flag == 1 ? 1 : 0));
@@ -623,7 +623,7 @@ static void nr_dlsch_mmse(uint32_t rx_size_symbol,
 
   //Copy zero_forcing out to output array
   for (int rtx = 0; rtx < nl; rtx++)
-    nr_element_sign(rxdataF_zforcing[rtx], rxdataF_comp[symbol][rtx * n_rx], nb_rb_0, +1);
+    nr_element_sign(rxdataF_zforcing[rtx], rxdataF_comp[symbol][rtx], nb_rb_0, +1);
 
   //Update LLR thresholds with the Matrix determinant
   simde__m128i *dl_ch_mag128_0=NULL,*dl_ch_mag128b_0=NULL,*dl_ch_mag128r_0=NULL,*determ_fin_128;
@@ -722,29 +722,29 @@ static int nr_dlsch_llr(const NR_UE_DLSCH_t *dlsch,
                         const c16_t dl_ch_magb[rx_size_symbol],
                         const c16_t dl_ch_magr[rx_size_symbol],
                         const int nb_antennas_rx,
-                        const c16_t rxdataF_comp[dlsch->cw_info.Nl * nb_antennas_rx][rx_size_symbol],
+                        const c16_t rxdataF_comp[dlsch->cw_info.Nl][rx_size_symbol],
                         const int llrSize,
                         int16_t layer_llr[dlsch->cw_info.Nl][llrSize])
 {
   switch (dlsch->cw_info.qamModOrder) {
     case 2 :
       for (int l = 0; l < dlsch->cw_info.Nl; l++)
-        nr_qpsk_llr(rxdataF_comp[l * nb_antennas_rx], layer_llr[l], len);
+        nr_qpsk_llr(rxdataF_comp[l], layer_llr[l], len);
       break;
 
     case 4 :
       for (int l = 0; l < dlsch->cw_info.Nl; l++)
-        nr_16qam_llr(rxdataF_comp[l * nb_antennas_rx], dl_ch_mag, layer_llr[l], len);
+        nr_16qam_llr(rxdataF_comp[l], dl_ch_mag, layer_llr[l], len);
       break;
 
     case 6 :
       for(int l=0; l < dlsch->cw_info.Nl; l++)
-        nr_64qam_llr(rxdataF_comp[l * nb_antennas_rx], dl_ch_mag, dl_ch_magb, layer_llr[l], len);
+        nr_64qam_llr(rxdataF_comp[l], dl_ch_mag, dl_ch_magb, layer_llr[l], len);
       break;
 
     case 8:
       for(int l=0; l < dlsch->cw_info.Nl; l++)
-        nr_256qam_llr(rxdataF_comp[l * nb_antennas_rx], dl_ch_mag, dl_ch_magb, dl_ch_magr, layer_llr[l], len);
+        nr_256qam_llr(rxdataF_comp[l], dl_ch_mag, dl_ch_magb, dl_ch_magr, layer_llr[l], len);
       break;
 
     default:
@@ -775,7 +775,7 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
                 int32_t *log2_maxh,
                 int rx_size_symbol,
                 int nbRx,
-                c16_t rxdataF_comp[][dlsch->cw_info.Nl * nbRx][rx_size_symbol],
+                c16_t rxdataF_comp[][dlsch->cw_info.Nl][rx_size_symbol],
                 c16_t dl_ch_mag[][dlsch->cw_info.Nl][rx_size_symbol],
                 c16_t dl_ch_magb[][dlsch->cw_info.Nl][rx_size_symbol],
                 c16_t dl_ch_magr[][dlsch->cw_info.Nl][rx_size_symbol],
@@ -799,13 +799,9 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
   // Reinterpret flat dl_ch_estimates_ext as [nl][nbRx][rx_size_symbol]
   c16_t(*chFext)[nbRx][rx_size_symbol] = (void *)dl_ch_estimates_ext;
 
-  // nr_channel_compensation reads rxComp[l * nb_rx_ant], so size nl * nbRx is required;
-  // MRC output is written per layer at row l * nbRx, the rest are unused.
-  // TODO: reduce to nl indices by changing rxComp indexing to rxComp[l] in nr_channel_compensation,
-  //       with matching gNB UL changes in a future MR.
-  c16_t *p_rxComp[nl * nbRx];
+  c16_t *p_rxComp[nl];
   for (int l = 0; l < nl; l++)
-    p_rxComp[l * nbRx] = rxdataF_comp[symbol][l * nbRx];
+    p_rxComp[l] = rxdataF_comp[symbol][l];
 
   NR_UE_COMMON *common_vars  = &ue->common_vars;
   const int frame = proc->frame_rx;
@@ -1140,7 +1136,7 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
         // rho_dl[llr_sym] is laid out as [nl*nl][rx_size_symbol]:
         // index 1 = rho[0][1], index nl (=2) = rho[1][0]
         nr_compute_ML_llr(rxdataF_comp[llr_sym][0],
-                          rxdataF_comp[llr_sym][nbRx],
+                          rxdataF_comp[llr_sym][1],
                           dl_ch_mag[llr_sym][0],
                           dl_ch_mag[llr_sym][1],
                           layer_llr[llr_sym][0],
@@ -1183,7 +1179,7 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
         UEunlockScopeData(ue, pdschRxdataF_comp)
       }
     } else {
-      UEscopeCopy(ue, pdschRxdataF_comp, rxdataF_comp[0], sizeof(c16_t), nbRx, rx_size_symbol, 0);
+      UEscopeCopy(ue, pdschRxdataF_comp, rxdataF_comp[0], sizeof(c16_t), nl, rx_size_symbol, 0);
     }
   }
 
@@ -1208,14 +1204,15 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
     T_BUFFER(&rxdataF_comp[gNB_id][0], 2 * fp->N_RB_DL * 12 * fp->symbols_per_slot * 2));
 #endif
 
-  if (ue->phy_sim_pdsch_rxdataF_comp)
+  if (ue->phy_sim_pdsch_rxdataF_comp) {
     for (int a = 0; a < nbRx; a++) {
-      for (int l = 0; l < nl; l++) {
-        int offset = (void *)rxdataF_comp[symbol][l * nbRx + a] - (void *)rxdataF_comp[0];
-        memcpy(ue->phy_sim_pdsch_rxdataF_comp + offset, rxdataF_comp[symbol][l * nbRx + a], sizeof(c16_t) * rx_size_symbol);
-      }
       memcpy((c16_t *)ue->phy_sim_pdsch_dl_ch_estimates + pdsch_est_size * a, dl_ch_estimates, pdsch_est_size * sizeof(c16_t));
     }
+    for (int l = 0; l < nl; l++) {
+      int offset = (void *)rxdataF_comp[symbol][l] - (void *)rxdataF_comp[0];
+      memcpy(ue->phy_sim_pdsch_rxdataF_comp + offset, rxdataF_comp[symbol][l], sizeof(c16_t) * rx_size_symbol);
+    }
+  }
   if (ue->phy_sim_pdsch_dl_ch_estimates_ext)
     memcpy(ue->phy_sim_pdsch_dl_ch_estimates_ext + symbol * sizeof(dl_ch_estimates_ext),
            dl_ch_estimates_ext,

openair1/PHY/NR_UE_TRANSPORT/nr_transport_proto_ue.h

@@ -277,7 +277,7 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
                 int32_t *log2_maxh,
                 int rx_size_symbol,
                 int nbRx,
-                c16_t rxdataF_comp[][dlsch->cw_info.Nl * nbRx][rx_size_symbol],
+                c16_t rxdataF_comp[][dlsch->cw_info.Nl][rx_size_symbol],
                 c16_t dl_ch_mag[][dlsch->cw_info.Nl][rx_size_symbol],
                 c16_t dl_ch_magb[][dlsch->cw_info.Nl][rx_size_symbol],
                 c16_t dl_ch_magr[][dlsch->cw_info.Nl][rx_size_symbol],

openair1/PHY/nr_phy_common/src/nr_channel_compensation.c

@@ -41,7 +41,7 @@ void nr_channel_compensation(uint32_t buffer_length,
   }
 
   for (int aatx = 0; aatx < nb_layers; aatx++) {
-    simde__m256i *rxComp_256 = (simde__m256i *)&rxComp[aatx * nb_rx_ant][symbol * buffer_length];
+    simde__m256i *rxComp_256 = (simde__m256i *)&rxComp[aatx][symbol * buffer_length];
     simde__m256i *ch_maga_256 = (simde__m256i *)ch_maga[aatx];
     simde__m256i *ch_magb_256 = (simde__m256i *)ch_magb[aatx];
     simde__m256i *ch_magc_256 = (simde__m256i *)ch_magc[aatx];

openair1/PHY/nr_phy_common/src/nr_compute_llr.c

@@ -2968,7 +2968,7 @@ uint8_t nr_mmse_2layers(c16_t **rxdataF_comp,
   simde__m128i *after_mf_d_128 = (simde__m128i *)af_mf_11;
 
   simde__m128i *rxdataF_comp128_0 = (simde__m128i *)&rxdataF_comp[0][symbol * buffer_length];
-  simde__m128i *rxdataF_comp128_1 = (simde__m128i *)&rxdataF_comp[nb_rx_ant][symbol * buffer_length];
+  simde__m128i *rxdataF_comp128_1 = (simde__m128i *)&rxdataF_comp[1][symbol * buffer_length];
 
   if (mod_order > 2) {
     if (mod_order == 4) {

openair1/SCHED_NR_UE/phy_procedures_nr_ue.c

@@ -475,13 +475,7 @@ static int nr_ue_pdsch_procedures(PHY_VARS_NR_UE *ue,
 
   const uint32_t rx_size_symbol = (freq_alloc->num_rbs * NR_NB_SC_PER_RB + 15) & ~15;
   fourDimArray_t *toFree2 = NULL;
-  allocCast3D(rxdataF_comp,
-              c16_t,
-              toFree2,
-              ue->frame_parms.symbols_per_slot,
-              dlsch->cw_info.Nl * ue->frame_parms.nb_antennas_rx,
-              rx_size_symbol,
-              false);
+  allocCast3D(rxdataF_comp, c16_t, toFree2, ue->frame_parms.symbols_per_slot, dlsch->cw_info.Nl, rx_size_symbol, false);
 
   uint32_t nvar = 0;
 

openair1/SIMULATION/NR_PHY/ulsim.c

@@ -1639,9 +1639,9 @@ int main(int argc, char *argv[])
                   1,
                   1 | log_format);
 
-            LOG_M("rxsigF2_comp.m",
-                  "rxsF2_comp",
-                  &pusch_vars->rxdataF_comp[2][start_symbol * (off + (NR_NB_SC_PER_RB * pusch_pdu->rb_size))],
+            LOG_M("rxsigF1_comp.m",
+                  "rxsF1_comp",
+                  &pusch_vars->rxdataF_comp[1][start_symbol * (off + (NR_NB_SC_PER_RB * pusch_pdu->rb_size))],
                   nb_symb_sch * (off + (NR_NB_SC_PER_RB * pusch_pdu->rb_size)),
                   1,
                   1 | log_format);
@@ -1667,21 +1667,15 @@ int main(int argc, char *argv[])
                   1,
                   1 | log_format);
 
-            LOG_M("rxsigF4_comp.m",
-                  "rxsF4_comp",
-                  &pusch_vars->rxdataF_comp[4][start_symbol * (off + (NR_NB_SC_PER_RB * pusch_pdu->rb_size))],
-                  nb_symb_sch * (off + (NR_NB_SC_PER_RB * pusch_pdu->rb_size)),
-                  1,
-                  1 | log_format);
-            LOG_M("rxsigF8_comp.m",
-                  "rxsF8_comp",
-                  &pusch_vars->rxdataF_comp[8][start_symbol * (off + (NR_NB_SC_PER_RB * pusch_pdu->rb_size))],
+            LOG_M("rxsigF2_comp.m",
+                  "rxsF2_comp",
+                  &pusch_vars->rxdataF_comp[2][start_symbol * (off + (NR_NB_SC_PER_RB * pusch_pdu->rb_size))],
                   nb_symb_sch * (off + (NR_NB_SC_PER_RB * pusch_pdu->rb_size)),
                   1,
                   1 | log_format);
-            LOG_M("rxsigF12_comp.m",
-                  "rxsF12_comp",
-                  &pusch_vars->rxdataF_comp[12][start_symbol * (off + (NR_NB_SC_PER_RB * pusch_pdu->rb_size))],
+            LOG_M("rxsigF3_comp.m",
+                  "rxsF3_comp",
+                  &pusch_vars->rxdataF_comp[3][start_symbol * (off + (NR_NB_SC_PER_RB * pusch_pdu->rb_size))],
                   nb_symb_sch * (off + (NR_NB_SC_PER_RB * pusch_pdu->rb_size)),
                   1,
                   1 | log_format);