Merge remote-tracking branch 'origin/oai_ue_mem_opt_v1' into integration_2026_w30

[NR UE] PDSCH Rx: Pre-allocate large buffers on heap (#234)

Performs memory optimization to speed up OAI UE.

1. Replace per slot memory allocation and free of buffers dl_ch_mag/b/r,
   rho_dl, rxdataF_comp and pdsch_dl_ch_estimates with one-time
   allocation at init and free at teardown by pre-allocating one buffer
   set per actor.
2. Remove unnecessary memset on buffers as they are immediately written
   afterwards before being read.
Reviewed-by: Robert Schmidt <robert.schmidt@openairinterface.org>
Reviewed-by: Sakthivel Velumani <s.velumani@northeastern.edu>

openair1/PHY/INIT/nr_init_ue.c

@@ -359,12 +359,28 @@ void free_nr_ue_ul_harq(NR_UL_UE_HARQ_t harq_list[NR_MAX_HARQ_PROCESSES], int nu
   }
 }
 
+void free_nr_ue_pdsch_buffers(pdsch_scratch_t *buffers, int num_actors)
+{
+  for (int i = 0; i < num_actors; i++) {
+    free_and_zero(buffers[i].rxdataF_comp);
+    free_and_zero(buffers[i].dl_ch_mag);
+    free_and_zero(buffers[i].dl_ch_magb);
+    free_and_zero(buffers[i].dl_ch_magr);
+    free_and_zero(buffers[i].rho_dl);
+    free_and_zero(buffers[i].pdsch_dl_ch_estimates);
+    for (int c = 0; c < 2; c++)
+      free_and_zero(buffers[i].llr[c]);
+  }
+}
+
 void term_nr_ue_transport(PHY_VARS_NR_UE *ue)
 {
   const int N_RB_DL = ue->frame_parms.N_RB_DL;
   const int N_RB_UL = ue->frame_parms.N_RB_UL;
   free_nr_ue_dl_harq(ue->dl_harq_processes, NR_MAX_HARQ_PROCESSES, N_RB_DL);
   free_nr_ue_ul_harq(ue->ul_harq_processes, NR_MAX_HARQ_PROCESSES, N_RB_UL, ue->frame_parms.nb_antennas_tx);
+  free_nr_ue_pdsch_buffers(ue->pdsch_scratch, ue->pdsch_num_actors);
+  free_and_zero(ue->pdsch_scratch);
 }
 
 void nr_init_dl_harq_processes(NR_DL_UE_HARQ_t harq_list[2][NR_MAX_HARQ_PROCESSES], int number_of_processes, int num_rb)
@@ -434,10 +450,37 @@ void nr_init_ul_harq_processes(NR_UL_UE_HARQ_t harq_list[NR_MAX_HARQ_PROCESSES],
   }
 }
 
+void nr_init_pdsch_buffers(pdsch_scratch_t *buffers, int num_actors, const NR_DL_FRAME_PARMS *fp)
+{
+  const uint32_t pdsch_buf_size_max = (fp->N_RB_DL * NR_NB_SC_PER_RB + 15) & ~15;
+  const uint32_t pdsch_est_size = fp->symbols_per_slot * fp->ofdm_symbol_size;
+  const uint32_t llr_buf_max = NR_NB_SC_PER_RB * NR_SYMBOLS_PER_SLOT * fp->N_RB_DL * 8 * NR_MAX_NB_LAYERS;
+  const size_t comp_elems = (size_t)NR_SYMBOLS_PER_SLOT * NR_MAX_NB_LAYERS * pdsch_buf_size_max;
+  const size_t rho_elems  = (size_t)NR_SYMBOLS_PER_SLOT * NR_MAX_NB_LAYERS * NR_MAX_NB_LAYERS * pdsch_buf_size_max;
+  const size_t ch_est_elems = (size_t)fp->nb_antennas_rx * NR_MAX_NB_LAYERS * pdsch_est_size;
+  for (int i = 0; i < num_actors; i++) {
+    buffers[i].pdsch_buf_size_max           = pdsch_buf_size_max;
+    buffers[i].pdsch_est_size        = pdsch_est_size;
+    buffers[i].llr_buf_max           = llr_buf_max;
+    buffers[i].rxdataF_comp          = malloc16_clear(comp_elems   * sizeof(c16_t));
+    buffers[i].dl_ch_mag             = malloc16_clear(comp_elems   * sizeof(c16_t));
+    buffers[i].dl_ch_magb            = malloc16_clear(comp_elems   * sizeof(c16_t));
+    buffers[i].dl_ch_magr            = malloc16_clear(comp_elems   * sizeof(c16_t));
+    buffers[i].rho_dl                = malloc16_clear(rho_elems    * sizeof(c16_t));
+    buffers[i].pdsch_dl_ch_estimates = malloc16_clear(ch_est_elems * sizeof(int32_t));
+    for (int c = 0; c < 2; c++)
+      buffers[i].llr[c]              = malloc16(llr_buf_max * sizeof(int16_t));
+  }
+}
+
 void init_nr_ue_transport(PHY_VARS_NR_UE *ue)
 {
   nr_init_dl_harq_processes(ue->dl_harq_processes, NR_MAX_HARQ_PROCESSES, ue->frame_parms.N_RB_DL);
   nr_init_ul_harq_processes(ue->ul_harq_processes, NR_MAX_HARQ_PROCESSES, ue->frame_parms.N_RB_UL, ue->frame_parms.nb_antennas_tx);
+  const int num_actors = get_nrUE_params()->num_dl_actors > 0 ? get_nrUE_params()->num_dl_actors : 1;
+  ue->pdsch_num_actors = num_actors;
+  ue->pdsch_scratch = calloc_or_fail(num_actors, sizeof(*ue->pdsch_scratch));
+  nr_init_pdsch_buffers(ue->pdsch_scratch, num_actors, &ue->frame_parms);
 }
 
 void clean_UE_harq(PHY_VARS_NR_UE *UE)

openair1/PHY/INIT/nr_phy_init.h

@@ -28,6 +28,8 @@ void nr_init_dl_harq_processes(NR_DL_UE_HARQ_t harq_list[2][NR_MAX_HARQ_PROCESSE
 void nr_init_ul_harq_processes(NR_UL_UE_HARQ_t harq_list[NR_MAX_HARQ_PROCESSES], int number_of_processes, int num_rb, int num_ant_tx);
 void free_nr_ue_dl_harq(NR_DL_UE_HARQ_t harq_list[2][NR_MAX_HARQ_PROCESSES], int number_of_processes, int num_rb);
 void free_nr_ue_ul_harq(NR_UL_UE_HARQ_t harq_list[NR_MAX_HARQ_PROCESSES], int number_of_processes, int num_rb, int num_ant_tx);
+void nr_init_pdsch_buffers(pdsch_scratch_t *buffers, int num_actors, const NR_DL_FRAME_PARMS *fp);
+void free_nr_ue_pdsch_buffers(pdsch_scratch_t *buffers, int num_actors);
 
 void phy_init_nr_top(PHY_VARS_NR_UE *ue);
 void phy_term_nr_top(void);

openair1/PHY/NR_TRANSPORT/nr_ulsch_demodulation.c

@@ -258,6 +258,7 @@ static void inner_rx(PHY_VARS_gNB *gNB,
     memset(&pusch_vars->rxdataF_comp[i][symbol * buffer_length], 0, sizeof(int32_t) * buffer_length);
 
   nr_channel_compensation(buffer_length,
+                          buffer_length,
                           nb_rx_ant,
                           nb_layer,
                           rxFext,
@@ -309,6 +310,7 @@ static void inner_rx(PHY_VARS_gNB *gNB,
     }
     else {
       nr_mmse_2layers(pusch_vars->rxdataF_comp,
+                      buffer_length,
                       buffer_length,
                       nb_rx_ant,
                       nb_layer,

openair1/PHY/NR_UE_ESTIMATION/nr_dl_channel_estimation.c

@@ -1343,9 +1343,9 @@ void nr_pdsch_channel_estimation(PHY_VARS_NR_UE *ue,
 void nr_pdsch_ptrs_processing(int nbRx,
                               c16_t ptrs_phase_per_slot[][14],
                               int32_t ptrs_re_per_slot[][14],
-                              uint32_t rx_size_symbol,
+                              uint32_t pdsch_buf_size_max,
                               int nl,
-                              c16_t rxdataF_comp[][nl][rx_size_symbol],
+                              c16_t rxdataF_comp[][NR_MAX_NB_LAYERS][pdsch_buf_size_max],
                               NR_DL_FRAME_PARMS *frame_parms,
                               fapi_nr_dl_config_dlsch_pdu_rel15_t *dlsch_config,
                               uint8_t nr_slot_rx,
@@ -1424,7 +1424,7 @@ void nr_pdsch_ptrs_processing(int nbRx,
       }
 #ifdef DEBUG_DL_PTRS
       LOG_M("ptrsEst.m","est", ptrs_phase_per_slot[aarx], frame_parms->symbols_per_slot, 1, 1);
-      LOG_M("rxdataF_bf_ptrs_comp.m", "bf_ptrs_cmp", rxdataF_comp[0][aarx] + startSymbIndex * rx_size_symbol, rx_size_symbol * nbSymb, 1, 1);
+      LOG_M("rxdataF_bf_ptrs_comp.m", "bf_ptrs_cmp", rxdataF_comp[0][aarx] + startSymbIndex * pdsch_buf_size_max, pdsch_buf_size_max * nbSymb, 1, 1);
 #endif
       /*------------------------------------------------------------------------------------------------------- */
       /* 3) Compensated DMRS based estimated signal with PTRS estimation                                        */

openair1/PHY/NR_UE_ESTIMATION/nr_estimation.h

@@ -117,9 +117,9 @@ void phy_adjust_gain_nr(PHY_VARS_NR_UE *ue,
 void nr_pdsch_ptrs_processing(int nbRx,
                               c16_t ptrs_phase_per_slot[][14],
                               int32_t ptrs_re_per_slot[][14],
-                              uint32_t rx_size_symbol,
+                              uint32_t pdsch_buf_size_max,
                               int nl,
-                              c16_t rxdataF_comp[][nl][rx_size_symbol],
+                              c16_t rxdataF_comp[][NR_MAX_NB_LAYERS][pdsch_buf_size_max],
                               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

@@ -523,17 +523,17 @@ void nr_conjch0_mult_ch1(c16_t *ch0, c16_t *ch1, c16_t *ch0conj_ch1, unsigned sh
 /*
  * MMSE Rx function: up to 4 layers
  */
-static void nr_dlsch_mmse(uint32_t rx_size_symbol,
+static void nr_dlsch_mmse(uint32_t pdsch_buf_size_max,
+                          uint32_t rx_size_symbol,
                           unsigned char n_rx,
                           unsigned char nl, // number of layer
-                          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],
+                          c16_t rxdataF_comp[nl][pdsch_buf_size_max],
+                          c16_t dl_ch_mag[][pdsch_buf_size_max],
+                          c16_t dl_ch_magb[][pdsch_buf_size_max],
+                          c16_t dl_ch_magr[][pdsch_buf_size_max],
                           int32_t dl_ch_estimates_ext[][rx_size_symbol],
                           unsigned char mod_order,
                           int shift,
-                          unsigned char symbol,
                           int length,
                           uint32_t noise_var)
 {
@@ -609,7 +609,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],
+                           rxdataF_comp[ctx],
                            outtemp,
                            sizeofArray(outtemp),
                            shift - (fp_flag == 1 ? 1 : 0));
@@ -625,7 +625,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], nb_rb_0, +1);
+    nr_element_sign(rxdataF_zforcing[rtx], rxdataF_comp[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;
@@ -699,12 +699,12 @@ static void nr_dlsch_layer_demapping(const uint8_t Nl,
 /* Computes LLRs from compensated PDSCH signal per OFDM symbol for all layers */
 static int nr_dlsch_llr(const NR_UE_DLSCH_t *dlsch,
                         const int len,
-                        const int rx_size_symbol,
-                        const c16_t dl_ch_mag[rx_size_symbol],
-                        const c16_t dl_ch_magb[rx_size_symbol],
-                        const c16_t dl_ch_magr[rx_size_symbol],
+                        const int pdsch_buf_size_max,
+                        const c16_t dl_ch_mag[pdsch_buf_size_max],
+                        const c16_t dl_ch_magb[pdsch_buf_size_max],
+                        const c16_t dl_ch_magr[pdsch_buf_size_max],
                         const int nb_antennas_rx,
-                        const c16_t rxdataF_comp[dlsch->cw_info.Nl][rx_size_symbol],
+                        const c16_t rxdataF_comp[dlsch->cw_info.Nl][pdsch_buf_size_max],
                         const int llrSize,
                         int16_t layer_llr[dlsch->cw_info.Nl][llrSize])
 {
@@ -755,23 +755,23 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
                 uint32_t dl_valid_re[NR_SYMBOLS_PER_SLOT],
                 c16_t rxdataF[][ue->frame_parms.samples_per_slot_wCP],
                 int32_t *log2_maxh,
-                int rx_size_symbol,
+                uint32_t pdsch_buf_size_max,
                 int nbRx,
-                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],
+                c16_t rxdataF_comp[][NR_MAX_NB_LAYERS][pdsch_buf_size_max],
+                c16_t dl_ch_mag[][NR_MAX_NB_LAYERS][pdsch_buf_size_max],
+                c16_t dl_ch_magb[][NR_MAX_NB_LAYERS][pdsch_buf_size_max],
+                c16_t dl_ch_magr[][NR_MAX_NB_LAYERS][pdsch_buf_size_max],
                 c16_t ptrs_phase_per_slot[][NR_SYMBOLS_PER_SLOT],
                 int32_t ptrs_re_per_slot[][NR_SYMBOLS_PER_SLOT],
                 uint32_t nvar,
                 pdsch_scope_req_t *scope_req,
-                c16_t rho_dl[][dlsch->cw_info.Nl * dlsch->cw_info.Nl][rx_size_symbol])
+                c16_t rho_dl[][NR_MAX_NB_LAYERS * NR_MAX_NB_LAYERS][pdsch_buf_size_max])
 {
   NR_DL_FRAME_PARMS *fp = &ue->frame_parms;
   const int nl = dlsch->cw_info.Nl;
   const int matrixSz = nbRx * nl;
+  const uint32_t rx_size_symbol = (freq_alloc->num_rbs * NR_NB_SC_PER_RB + 15) & ~15;
   __attribute__((aligned(32))) int32_t dl_ch_estimates_ext[matrixSz][rx_size_symbol];
-  memset(dl_ch_estimates_ext, 0, sizeof(dl_ch_estimates_ext));
 
   // Use ML-based LLR for 2-layer MIMO with QPSK/16QAM/64QAM (nl==2, qamModOrder<=6).
   // Controlled by ue->do_ml (set via -E flag in dlsim, or ue->do_ml in the UE struct).
@@ -973,6 +973,7 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
   //----------------------------------------------------------
   start_meas_nr_ue_phy(ue, DLSCH_CHANNEL_COMPENSATION_STATS);
   nr_channel_compensation(rx_size_symbol,
+                          pdsch_buf_size_max,
                           nbRx,
                           nl,
                           rxdataF_ext,
@@ -981,7 +982,7 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
                           dl_ch_magb[symbol],
                           dl_ch_magr[symbol],
                           p_rxComp,
-                          need_rho ? (c16_t(*)[nl][rx_size_symbol])rho_dl[symbol] : NULL,
+                          need_rho ? (c16_t(*)[nl][pdsch_buf_size_max])rho_dl[symbol] : NULL,
                           dlsch->cw_info.qamModOrder,
                           0, // symbol already baked into p_rxComp
                           *log2_maxh);
@@ -1008,7 +1009,7 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
   snprintf(filename, 50, "dl_ch_estimates_ext0_symb_%d_nr_slot_rx_%d.m", symbol, nr_slot_rx);
   write_output(filename, "dl_ch_estimates_ext0", &dl_ch_estimates_ext[0][0], rx_size_symbol, 1, 1);
   snprintf(filename, 50, "rxdataF_comp00_symb_%d_nr_slot_rx_%d.m", symbol, nr_slot_rx);
-  write_output(filename, "rxdataF_comp00", &rxdataF_comp[0][0][symbol * rx_size_symbol], rx_size_symbol, 1, 1);
+  write_output(filename, "rxdataF_comp00", &rxdataF_comp[0][0][symbol * pdsch_buf_size_max], pdsch_buf_size_max, 1, 1);
 #endif
 
   // MRC is performed inline by nr_channel_compensation; apply MMSE for multi-layer
@@ -1017,22 +1018,23 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
     const uint8_t qamModOrder = dlsch->cw_info.qamModOrder;
 
     if ((nl > 2) || (nl == 2 && !do_ml)) {
-      nr_dlsch_mmse(rx_size_symbol,
+      nr_dlsch_mmse(pdsch_buf_size_max,
+                    rx_size_symbol,
                     nbRx,
                     nl,
-                    rxdataF_comp,
+                    rxdataF_comp[symbol],
                     dl_ch_mag[symbol],
                     dl_ch_magb[symbol],
                     dl_ch_magr[symbol],
                     dl_ch_estimates_ext,
                     qamModOrder,
                     *log2_maxh,
-                    symbol,
                     nb_re_pdsch,
                     nvar);
     } else if ((nl == 2) && (qamModOrder > 6) && do_ml) {
       nr_mmse_2layers(p_rxComp,
                       rx_size_symbol,
+                      pdsch_buf_size_max,
                       nbRx,
                       nl,
                       dl_ch_mag[symbol],
@@ -1081,7 +1083,7 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
     nr_pdsch_ptrs_processing(1, // rxdataF_comp is MRCed so no point in processing all antenna ports. Fixme.
                              ptrs_phase_per_slot,
                              ptrs_re_per_slot,
-                             rx_size_symbol,
+                             pdsch_buf_size_max,
                              nl,
                              rxdataF_comp,
                              fp,
@@ -1124,7 +1126,7 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
       } else {
         nr_dlsch_llr(dlsch,
                      dl_valid_re[llr_sym],
-                     rx_size_symbol,
+                     pdsch_buf_size_max,
                      dl_ch_mag[llr_sym][0],
                      dl_ch_magb[llr_sym][0],
                      dl_ch_magr[llr_sym][0],
@@ -1155,7 +1157,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), nl, rx_size_symbol, 0);
+      UEscopeCopy(ue, pdschRxdataF_comp, rxdataF_comp[0], sizeof(c16_t), nl, pdsch_buf_size_max, 0);
     }
   }
 
@@ -1186,7 +1188,7 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
     }
     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);
+      memcpy(ue->phy_sim_pdsch_rxdataF_comp + offset, rxdataF_comp[symbol][l], sizeof(c16_t) * pdsch_buf_size_max);
     }
   }
   if (ue->phy_sim_pdsch_dl_ch_estimates_ext)

openair1/PHY/NR_UE_TRANSPORT/nr_transport_proto_ue.h

@@ -247,17 +247,17 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
                 uint32_t dl_valid_re[NR_SYMBOLS_PER_SLOT],
                 c16_t rxdataF[][ue->frame_parms.samples_per_slot_wCP],
                 int32_t *log2_maxh,
-                int rx_size_symbol,
+                uint32_t pdsch_buf_size_max,
                 int nbRx,
-                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],
+                c16_t rxdataF_comp[][NR_MAX_NB_LAYERS][pdsch_buf_size_max],
+                c16_t dl_ch_mag[][NR_MAX_NB_LAYERS][pdsch_buf_size_max],
+                c16_t dl_ch_magb[][NR_MAX_NB_LAYERS][pdsch_buf_size_max],
+                c16_t dl_ch_magr[][NR_MAX_NB_LAYERS][pdsch_buf_size_max],
                 c16_t ptrs_phase_per_slot[][NR_SYMBOLS_PER_SLOT],
                 int32_t ptrs_re_per_slot[][NR_SYMBOLS_PER_SLOT],
                 uint32_t nvar,
                 pdsch_scope_req_t *scope_req,
-                c16_t rho_dl[][dlsch->cw_info.Nl * dlsch->cw_info.Nl][rx_size_symbol]);
+                c16_t rho_dl[][NR_MAX_NB_LAYERS * NR_MAX_NB_LAYERS][pdsch_buf_size_max]);
 
 int32_t generate_nr_prach(PHY_VARS_NR_UE *ue, uint8_t gNB_id, int frame, uint8_t slot, c16_t **txData);
 void apply_ntn_config(PHY_VARS_NR_UE *UE,

openair1/PHY/defs_nr_UE.h

@@ -443,7 +443,22 @@ typedef struct PHY_VARS_NR_UE_s {
   Actor_t *ul_actors;
   pthread_t main_thread;
   pthread_t stat_thread;
+  // Per-DL-actor pre-allocated PDSCH scratch buffers (one set per actor to avoid races)
+  struct pdsch_scratch_s {
+    c16_t   *rxdataF_comp;          // [NR_SYMBOLS_PER_SLOT][NR_MAX_NB_LAYERS][pdsch_buf_size_max]
+    c16_t   *dl_ch_mag;             // [NR_SYMBOLS_PER_SLOT][NR_MAX_NB_LAYERS][pdsch_buf_size_max]
+    c16_t   *dl_ch_magb;            // [NR_SYMBOLS_PER_SLOT][NR_MAX_NB_LAYERS][pdsch_buf_size_max]
+    c16_t   *dl_ch_magr;            // [NR_SYMBOLS_PER_SLOT][NR_MAX_NB_LAYERS][pdsch_buf_size_max]
+    c16_t   *rho_dl;                // [NR_SYMBOLS_PER_SLOT][NR_MAX_NB_LAYERS*NR_MAX_NB_LAYERS][pdsch_buf_size_max]
+    int32_t *pdsch_dl_ch_estimates; // [nb_antennas_rx*NR_MAX_NB_LAYERS][pdsch_est_size]
+    int16_t *llr[2];               // [2 codewords][llr_buf_max]
+    uint32_t pdsch_buf_size_max;
+    uint32_t pdsch_est_size;
+    uint32_t llr_buf_max;
+  } *pdsch_scratch;
+  int pdsch_num_actors;
 } PHY_VARS_NR_UE;
+typedef struct pdsch_scratch_s pdsch_scratch_t;
 
 typedef struct {
   openair0_timestamp_t timestamp_tx;

openair1/PHY/nr_phy_common/inc/nr_channel_compensation.h

@@ -15,31 +15,36 @@
  * from all Rx antennas are accumulated into rxComp[layer * nb_rx_ant][symbol * buffer_length].
  * Uses AVX2 (256-bit SIMD) for throughput.
  *
- * @param buffer_length   Number of complex samples per symbol (must be a multiple of 8)
+ * @param buffer_length   Number of complex samples per symbol (must be a multiple of 8);
+ *                        governs the loop count and the inner dim of rxFext/chFext.
+ * @param pdsch_buf_size_max     Inner dimension of ch_maga/ch_magb/ch_magc/rho arrays.
+ *                        Pass the pre-allocated worst-case size for DL per-actor scratch
+ *                        buffers so that multi-layer row strides are correct.
  * @param nb_rx_ant       Number of Rx antennas
  * @param nb_layers       Number of spatial layers
  * @param rxFext          Extracted received signal [nb_rx_ant][buffer_length]
  * @param chFext          Extracted channel estimates [nb_layers][nb_rx_ant][buffer_length]
- * @param ch_maga         Output magnitude array for threshold 'a' [nb_layers][buffer_length]
- * @param ch_magb         Output magnitude array for threshold 'b' [nb_layers][buffer_length]
- * @param ch_magc         Output magnitude array for threshold 'c' [nb_layers][buffer_length]
+ * @param ch_maga         Output magnitude array for threshold 'a' [nb_layers][pdsch_buf_size_max]
+ * @param ch_magb         Output magnitude array for threshold 'b' [nb_layers][pdsch_buf_size_max]
+ * @param ch_magc         Output magnitude array for threshold 'c' [nb_layers][pdsch_buf_size_max]
  * @param rxComp          Output compensated signal; row [l * nb_rx_ant] holds the MRC result
  *                        for layer l at offset [symbol * buffer_length]
- * @param rho             Tx-correlation matrix [nb_layers][nb_layers][buffer_length], or NULL
+ * @param rho             Tx-correlation matrix [nb_layers][nb_layers][pdsch_buf_size_max], or NULL
  * @param mod_order       Modulation order (2=QPSK, 4=16QAM, 6=64QAM, 8=256QAM)
  * @param symbol          OFDM symbol index (used to compute offset into rxComp rows)
  * @param output_shift    Right-shift applied after each complex multiply
  */
 void nr_channel_compensation(uint32_t buffer_length,
+                             uint32_t pdsch_buf_size_max,
                              int nb_rx_ant,
                              int nb_layers,
                              c16_t rxFext[nb_rx_ant][buffer_length],
                              c16_t chFext[nb_layers][nb_rx_ant][buffer_length],
-                             c16_t ch_maga[nb_layers][buffer_length],
-                             c16_t ch_magb[nb_layers][buffer_length],
-                             c16_t ch_magc[nb_layers][buffer_length],
+                             c16_t ch_maga[nb_layers][pdsch_buf_size_max],
+                             c16_t ch_magb[nb_layers][pdsch_buf_size_max],
+                             c16_t ch_magc[nb_layers][pdsch_buf_size_max],
                              c16_t **rxComp,
-                             c16_t (*rho)[nb_layers][buffer_length],
+                             c16_t (*rho)[nb_layers][pdsch_buf_size_max],
                              int mod_order,
                              uint32_t symbol,
                              uint32_t output_shift);

openair1/PHY/nr_phy_common/inc/nr_compute_llr.h

@@ -47,11 +47,12 @@ void nr_compute_ML_llr(c16_t *rxdataF_comp0,
 
 uint8_t nr_mmse_2layers(c16_t **rxdataF_comp,
                         uint32_t buffer_length,
+                        uint32_t pdsch_buf_size_max,
                         int nb_rx_ant,
                         int nb_layers,
-                        c16_t ch_mag[nb_layers][buffer_length],
-                        c16_t ch_magb[nb_layers][buffer_length],
-                        c16_t ch_magc[nb_layers][buffer_length],
+                        c16_t ch_mag[nb_layers][pdsch_buf_size_max],
+                        c16_t ch_magb[nb_layers][pdsch_buf_size_max],
+                        c16_t ch_magc[nb_layers][pdsch_buf_size_max],
                         c16_t ch_estimates_ext[][nb_rx_ant][buffer_length],
                         unsigned short nb_rb,
                         unsigned char mod_order,

openair1/PHY/nr_phy_common/src/nr_channel_compensation.c

@@ -12,15 +12,16 @@
 #endif
 
 void nr_channel_compensation(uint32_t buffer_length,
+                             uint32_t pdsch_buf_size_max,
                              int nb_rx_ant,
                              int nb_layers,
                              c16_t rxFext[nb_rx_ant][buffer_length],
                              c16_t chFext[nb_layers][nb_rx_ant][buffer_length],
-                             c16_t ch_maga[nb_layers][buffer_length],
-                             c16_t ch_magb[nb_layers][buffer_length],
-                             c16_t ch_magc[nb_layers][buffer_length],
+                             c16_t ch_maga[nb_layers][pdsch_buf_size_max],
+                             c16_t ch_magb[nb_layers][pdsch_buf_size_max],
+                             c16_t ch_magc[nb_layers][pdsch_buf_size_max],
                              c16_t **rxComp,
-                             c16_t (*rho)[nb_layers][buffer_length],
+                             c16_t (*rho)[nb_layers][pdsch_buf_size_max],
                              int mod_order,
                              uint32_t symbol,
                              uint32_t output_shift)

openair1/PHY/nr_phy_common/src/nr_compute_llr.c

@@ -2757,11 +2757,12 @@ static void nr_construct_HhH_elements(c16_t *conjch00_ch00,
 // MMSE Rx function: nr_mmse_2layers()
 uint8_t nr_mmse_2layers(c16_t **rxdataF_comp,
                         uint32_t buffer_length,
+                        uint32_t pdsch_buf_size_max,
                         int nb_rx_ant,
                         int nb_layers,
-                        c16_t ch_mag[nb_layers][buffer_length],
-                        c16_t ch_magb[nb_layers][buffer_length],
-                        c16_t ch_magc[nb_layers][buffer_length],
+                        c16_t ch_mag[nb_layers][pdsch_buf_size_max],
+                        c16_t ch_magb[nb_layers][pdsch_buf_size_max],
+                        c16_t ch_magc[nb_layers][pdsch_buf_size_max],
                         c16_t ch_estimates_ext[][nb_rx_ant][buffer_length],
                         unsigned short nb_rb,
                         unsigned char mod_order,

openair1/SCHED_NR_UE/phy_procedures_nr_ue.c

@@ -430,9 +430,16 @@ static int nr_ue_pdsch_procedures(PHY_VARS_NR_UE *ue,
         dlschCfg->dlDmrsSymbPos,
         dlsch->cw_info.Nl);
 
-  const uint32_t pdsch_est_size = ((ue->frame_parms.symbols_per_slot * ue->frame_parms.ofdm_symbol_size + 15) / 16) * 16;
-  fourDimArray_t *toFree = NULL;
-  allocCast2D(pdsch_dl_ch_estimates, int32_t, toFree, ue->frame_parms.nb_antennas_rx * dlsch->cw_info.Nl, pdsch_est_size, false);
+  const int actor_idx = proc->nr_slot_rx % ue->pdsch_num_actors;
+  pdsch_scratch_t *scratch = &ue->pdsch_scratch[actor_idx];
+  const uint32_t pdsch_est_size = scratch->pdsch_est_size;
+  const uint32_t pdsch_buf_size_max = scratch->pdsch_buf_size_max;
+  int32_t (*pdsch_dl_ch_estimates)[pdsch_est_size] = (int32_t (*)[pdsch_est_size])scratch->pdsch_dl_ch_estimates;
+  c16_t (*rxdataF_comp)[NR_MAX_NB_LAYERS][pdsch_buf_size_max] = (c16_t (*)[NR_MAX_NB_LAYERS][pdsch_buf_size_max])scratch->rxdataF_comp;
+  c16_t (*dl_ch_mag)[NR_MAX_NB_LAYERS][pdsch_buf_size_max]    = (c16_t (*)[NR_MAX_NB_LAYERS][pdsch_buf_size_max])scratch->dl_ch_mag;
+  c16_t (*dl_ch_magb)[NR_MAX_NB_LAYERS][pdsch_buf_size_max]   = (c16_t (*)[NR_MAX_NB_LAYERS][pdsch_buf_size_max])scratch->dl_ch_magb;
+  c16_t (*dl_ch_magr)[NR_MAX_NB_LAYERS][pdsch_buf_size_max]   = (c16_t (*)[NR_MAX_NB_LAYERS][pdsch_buf_size_max])scratch->dl_ch_magr;
+  c16_t (*rho_dl)[NR_MAX_NB_LAYERS * NR_MAX_NB_LAYERS][pdsch_buf_size_max] = (c16_t (*)[NR_MAX_NB_LAYERS * NR_MAX_NB_LAYERS][pdsch_buf_size_max])scratch->rho_dl;
 
   c16_t ptrs_phase_per_slot[ue->frame_parms.nb_antennas_rx][NR_SYMBOLS_PER_SLOT];
   memset(ptrs_phase_per_slot, 0, sizeof(ptrs_phase_per_slot));
@@ -440,10 +447,6 @@ static int nr_ue_pdsch_procedures(PHY_VARS_NR_UE *ue,
   int32_t ptrs_re_per_slot[ue->frame_parms.nb_antennas_rx][NR_SYMBOLS_PER_SLOT];
   memset(ptrs_re_per_slot, 0, sizeof(ptrs_re_per_slot));
 
-  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, rx_size_symbol, false);
-
   uint32_t nvar = 0;
 
   start_meas_nr_ue_phy(ue, DLSCH_CHANNEL_ESTIMATION_STATS);
@@ -525,19 +528,6 @@ static int nr_ue_pdsch_procedures(PHY_VARS_NR_UE *ue,
                                                          freq_alloc->num_rbs * NR_NB_SC_PER_RB * dlschCfg->number_symbols,
                                                          &mt);
   }
-  fourDimArray_t *toFree3 = NULL;
-  allocCast3D(dl_ch_mag, c16_t, toFree3, NR_SYMBOLS_PER_SLOT, dlsch->cw_info.Nl, rx_size_symbol, false);
-  fourDimArray_t *toFree4 = NULL;
-  allocCast3D(dl_ch_magb, c16_t, toFree4, NR_SYMBOLS_PER_SLOT, dlsch->cw_info.Nl, rx_size_symbol, false);
-  fourDimArray_t *toFree5 = NULL;
-  allocCast3D(dl_ch_magr, c16_t, toFree5, NR_SYMBOLS_PER_SLOT, dlsch->cw_info.Nl, rx_size_symbol, false);
-  fourDimArray_t *toFreeRho = NULL;
-  const bool need_rho = ue->do_ml && dlsch->cw_info.Nl == 2 && dlsch->cw_info.qamModOrder <= 6;
-  c16_t(*rho_dl)[dlsch->cw_info.Nl * dlsch->cw_info.Nl][rx_size_symbol] = NULL;
-  if (need_rho) {
-    allocCast3D(rho_dl_buf, c16_t, toFreeRho, NR_SYMBOLS_PER_SLOT, dlsch->cw_info.Nl * dlsch->cw_info.Nl, rx_size_symbol, false);
-    rho_dl = rho_dl_buf;
-  }
 
   for (int m = dlschCfg->start_symbol; m < (dlschCfg->number_symbols + dlschCfg->start_symbol); m++) {
     bool first_symbol_flag = false;
@@ -561,7 +551,7 @@ static int nr_ue_pdsch_procedures(PHY_VARS_NR_UE *ue,
                     dl_valid_re,
                     rxdataF,
                     &log2_maxh,
-                    rx_size_symbol,
+                    pdsch_buf_size_max,
                     ue->frame_parms.nb_antennas_rx,
                     rxdataF_comp,
                     dl_ch_mag,
@@ -589,12 +579,6 @@ static int nr_ue_pdsch_procedures(PHY_VARS_NR_UE *ue,
   if (scope_req.copy_rxdataF_to_scope) {
     UEunlockScopeData(ue, pdschRxdataF);
   }
-  free(toFree);
-  free(toFree2);
-  free(toFree3);
-  free(toFree4);
-  free(toFree5);
-  free(toFreeRho);
   return 0;
 }
 
@@ -1185,7 +1169,8 @@ void pdsch_processing(PHY_VARS_NR_UE *ue, const UE_nr_rxtx_proc_t *proc, nr_phy_
     }
   }
 
-  int16_t *llr[2];
+  const int actor_idx_llr = proc->nr_slot_rx % ue->pdsch_num_actors;
+  int16_t **llr = ue->pdsch_scratch[actor_idx_llr].llr;
   fapi_nr_dl_config_dlsch_pdu_rel15_t *dlsch_config = &phy_data->dlsch_config;
   for (int c = 0; c < phy_data->n_dlsch_codewords; c++) {
     NR_UE_DLSCH_t *dlsch = &phy_data->dlsch[c];
@@ -1234,7 +1219,6 @@ void pdsch_processing(PHY_VARS_NR_UE *ue, const UE_nr_rxtx_proc_t *proc, nr_phy_
                      dlsch->cw_info.qamModOrder,
                      dlsch->cw_info.Nl);
     const uint32_t rx_llr_buf_sz = ALIGNARRAYSIZE(G, 32); // each LLR is 2 bytes hence 64 byte aligned
-    llr[c] = (int16_t *)malloc16_clear(rx_llr_buf_sz * sizeof(int16_t));
 
     // dlsch_harq contains the previous transmissions data for this harq pid
     NR_DL_UE_HARQ_t *harq = &ue->dl_harq_processes[c][dlsch_config->harq_process_nbr];
@@ -1271,7 +1255,6 @@ void pdsch_processing(PHY_VARS_NR_UE *ue, const UE_nr_rxtx_proc_t *proc, nr_phy_
     if (ue->phy_sim_pdsch_llr)
       memcpy(ue->phy_sim_pdsch_llr, llr[c], sizeof(int16_t) * rx_llr_buf_sz);
 
-    free(llr[c]);
   }
 
   if (nr_slot_rx==9) {