make smaller and more accurate buffer ul_ch_estimates_ext, dl_ch_estimates_ext. Leads to fix bad C types in several functions

common/utils/ds/seq_arr.c

@@ -37,13 +37,11 @@ static void maybe_shrink(seq_arr_t* arr)
   }
 }
 
-void seq_arr_init(seq_arr_t* arr, size_t elt_size) //__attribute__(malloc)
+seq_arr_t seq_arr_init(size_t elt_size) //__attribute__(malloc)
 {
-  assert(arr != NULL);
-  seq_arr_t tmp = {.data = NULL, .size = 0, .elt_size = elt_size, .cap = MIN_SIZE};
-  memcpy(arr, &tmp, sizeof(seq_arr_t));
-  arr->data = calloc(arr->cap, elt_size);
-  assert(arr->data != NULL);
+  void* data = calloc(MIN_SIZE, elt_size);
+  assert(data != NULL);
+  return (seq_arr_t){.data = data, .elt_size = elt_size, .cap = MIN_SIZE};
 }
 
 void seq_arr_free(seq_arr_t* arr, void (*free_func)(void*))

common/utils/ds/seq_arr.h

@@ -22,7 +22,7 @@
 typedef struct seq_arr_s {
   uint8_t* data;
   size_t size;
-  const size_t elt_size;
+  size_t elt_size;
   size_t cap;
 } seq_arr_t;
 
@@ -32,7 +32,7 @@ typedef struct seq_arr_s {
  * @param arr The sequence container
  * @param elm_sz value returned by the sizeof operator of the type that the container will hold e.g., sizeof(int).
  */
-void seq_arr_init(seq_arr_t* arr, size_t elm_sz);
+seq_arr_t seq_arr_init(size_t elm_sz);
 
 /**
  * Free a sequence container, similar to a destructor

common/utils/ds/tests/test_seq_array.c

@@ -49,8 +49,7 @@ static void dummy_free_func(void* it)
 
 int main()
 {
-  seq_arr_t arr = {0};
-  seq_arr_init(&arr, sizeof(int));
+  seq_arr_t arr = seq_arr_init(sizeof(int));
 
   // Insert data and expand
   for (int i = 0; i < 100; ++i)

common/utils/system.c

@@ -225,18 +225,27 @@ bool has_cap_sys_nice(void)
 bool has_cap_sys_nice(void)
 {
   struct __user_cap_header_struct hdr = {.version = _LINUX_CAPABILITY_VERSION_3};
-  struct __user_cap_data_struct cap[2];
+  struct __user_cap_data_struct cap[2] = {};
   if (syscall(SYS_capget, &hdr, cap) == -1)
     return false;
   return (cap[0].effective & (1 << CAP_SYS_NICE)) != 0;
 }
 #endif
 
+ssize_t get_stack_usage()
+{
+  pthread_attr_t attr;
+  void *stack_base;
+  size_t stack_size;
+  pthread_getattr_np(pthread_self(), &attr);
+  pthread_attr_getstack(&attr, &stack_base, &stack_size);
+  return (intptr_t)&stack_base - (intptr_t)stack_base;
+}
+
 void threadCreate(pthread_t* t, void * (*func)(void*), void * param, char* name, int affinity, int priority)
 {
   int ret;
   bool set_prio = has_cap_sys_nice();
-
   pthread_attr_t attr;
   ret=pthread_attr_init(&attr);
   AssertFatal(ret == 0, "Error in pthread_attr_init(): ret: %d, errno: %d\n", ret, errno);

common/utils/system.h

@@ -7,6 +7,7 @@
 #include <stdint.h>
 #include <pthread.h>
 #include <stdbool.h>
+#include <sys/types.h>
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -29,8 +30,11 @@ void start_background_system(void);
 void lock_memory_to_ram(void);
 
 bool has_cap_sys_nice(void);
+ssize_t get_stack_usage();
 void threadCreate(pthread_t *t, void *(*func)(void *), void *param, char *name, int affinity, int priority);
-
+#define check_vla(decl_vla) \
+  decl_vla;                 \
+  LOG_D(UTIL, "remain stack %lu KB\n", get_stack_usage() / 1024);
 #define SCHED_OAI SCHED_RR
 #define OAI_PRIORITY_RT_LOW sched_get_priority_min(SCHED_OAI)
 #define OAI_PRIORITY_RT ((sched_get_priority_min(SCHED_OAI)+sched_get_priority_max(SCHED_OAI))/2)

openair1/PHY/INIT/nr_init.c

@@ -185,11 +185,9 @@ void phy_init_nr_gNB(PHY_VARS_gNB *gNB)
   gNB->pusch_vars = (NR_gNB_PUSCH *)malloc16_clear(gNB->max_nb_pusch * sizeof(NR_gNB_PUSCH));
   for (int ULSCH_id = 0; ULSCH_id < gNB->max_nb_pusch; ULSCH_id++) {
     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);
     }
@@ -198,7 +196,6 @@ void phy_init_nr_gNB(PHY_VARS_gNB *gNB)
     }
     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
-    pusch->ul_valid_re_per_slot = (int16_t *)malloc16_clear(sizeof(int16_t) * fp->symbols_per_slot);
   } // ulsch_id
 }
 
@@ -251,13 +248,10 @@ void phy_free_nr_gNB(PHY_VARS_gNB *gNB)
   for (int ULSCH_id = 0; ULSCH_id < gNB->max_nb_pusch; ULSCH_id++) {
     NR_gNB_PUSCH *pusch_vars = &gNB->pusch_vars[ULSCH_id];
     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]);
     }
-    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);
     free_and_zero(pusch_vars->rxdataF_comp);
 
     free_and_zero(pusch_vars->llr);

openair1/PHY/NR_ESTIMATION/nr_ul_channel_estimation.c

@@ -27,7 +27,6 @@
 
 typedef struct puschAntennaProc_s {
   unsigned char Ns;
-  int nl;
   unsigned short p;
   unsigned char symbol;
   unsigned short bwp_start_subcarrier;
@@ -41,13 +40,14 @@ typedef struct puschAntennaProc_s {
   uint64_t *noise_amp2;
   delay_t *delay;
   int chest_freq;
-  NR_gNB_PUSCH *pusch_vars;
   NR_DL_FRAME_PARMS *frame_parms;
   c16_t ***rxdataF;
   task_ans_t *ans;
   scopeData_t *scope;
   c16_t *pusch_ch_est_dmrs_pos_slot_mem;
   int dmrs_symbol_start_idx;
+  int ul_ch_estimates_sz;
+  c16_t *ul_ch_estimates;
 } puschAntennaProc_t;
 
 __attribute__((always_inline)) inline c16_t c32x16cumulVectVectWithSteps(c16_t *in1,
@@ -76,7 +76,6 @@ static void nr_pusch_antenna_processing(void *arg)
 {
   puschAntennaProc_t *rdata = (puschAntennaProc_t *)arg;
   unsigned char Ns = rdata->Ns;
-  int nl = rdata->nl;
   unsigned short p = rdata->p;
   unsigned char symbol = rdata->symbol;
   int aarx = rdata->aarx;
@@ -90,8 +89,6 @@ static void nr_pusch_antenna_processing(void *arg)
   delay_t *delay = rdata->delay;
 
   const int chest_freq = rdata->chest_freq;
-  NR_gNB_PUSCH *pusch_vars = rdata->pusch_vars;
-  c16_t **ul_ch_estimates = (c16_t **)pusch_vars->ul_ch_estimates;
   NR_DL_FRAME_PARMS *frame_parms = rdata->frame_parms;
   const int symbolSize = frame_parms->ofdm_symbol_size;
   const int slot_offset = (Ns % RU_RX_SLOT_DEPTH) * frame_parms->symbols_per_slot * symbolSize;
@@ -100,12 +97,13 @@ static void nr_pusch_antenna_processing(void *arg)
   const int k0 = bwp_start_subcarrier;
   const int nb_rb_pusch = pusch_pdu->rb_size;
   const int beam_nb = rdata->beam_nb;
+  c16_t(*ul_ch_estimates)[rdata->ul_ch_estimates_sz] = (c16_t(*)[rdata->ul_ch_estimates_sz])rdata->ul_ch_estimates;
   for (int antenna = aarx; antenna < aarx + numAntennas; antenna++) {
     c16_t ul_ls_est[symbolSize] __attribute__((aligned(32)));
     memset(ul_ls_est, 0, sizeof(c16_t) * symbolSize);
     c16_t *rxdataF = (c16_t *)&rdata->rxdataF[beam_nb][antenna][symbol_offset + slot_offset];
-    c16_t *ul_ch = &ul_ch_estimates[nl * frame_parms->nb_antennas_rx + antenna][symbol_offset];
-    memset(ul_ch, 0, sizeof(*ul_ch) * symbolSize);
+    c16_t *ul_ch = ul_ch_estimates[aarx];
+    memset(ul_ch, 0, sizeof(*ul_ch) * rdata->ul_ch_estimates_sz);
 
     LOG_D(PHY,
           "symbol_offset %d, slot_offset %d, OFDM size %d, Ns = %d, k0 = %d, symbol %d\n",
@@ -219,7 +217,7 @@ static void nr_pusch_antenna_processing(void *arg)
 
       // Revert delay
       pilot_cnt = 0;
-      ul_ch = &ul_ch_estimates[nl * frame_parms->nb_antennas_rx + antenna][symbol_offset];
+      ul_ch = ul_ch_estimates[aarx];
       int inv_delay_idx = get_delay_idx(-delay->est_delay, MAX_DELAY_COMP);
       c16_t *ul_inv_delay_table = frame_parms->delay_table[inv_delay_idx];
       for (int n = 0; n < 3 * nb_rb_pusch; n++) {
@@ -431,7 +429,7 @@ static void nr_pusch_antenna_processing(void *arg)
     }
 
 #ifdef DEBUG_PUSCH
-    ul_ch = &ul_ch_estimates[nl * gNB->frame_parms.nb_antennas_rx + aarx][symbol_offset];
+    ul_ch = ul_ch_estimates[aarx];
     for (int idxP = 0; idxP < ceil((float)nb_rb_pusch * 12 / 8); idxP++) {
       for (int idxI = 0; idxI < 8; idxI++) {
         printf("%d\t%d\t", ul_ch[idxP * 8 + idxI].r, ul_ch[idxP * 8 + idxI].i);
@@ -446,7 +444,6 @@ static void nr_pusch_antenna_processing(void *arg)
   completed_task_ans(rdata->ans);
 }
 
-
 int nr_pusch_channel_estimation(PHY_VARS_gNB *gNB,
                                 unsigned char Ns,
                                 int nl,
@@ -459,7 +456,9 @@ int nr_pusch_channel_estimation(PHY_VARS_gNB *gNB,
                                 int *max_ch,
                                 uint32_t *nvar,
                                 c16_t *pusch_dmrs_slot_mem,
-                                c16_t *pusch_ch_est_dmrs_pos_slot_mem)
+                                c16_t *pusch_ch_est_dmrs_pos_slot_mem,
+                                int sz,
+                                c16_t ul_ch_estim[][sz])
 {
   c16_t pilot[3280] __attribute__((aligned(32)));
 
@@ -565,7 +564,6 @@ int nr_pusch_channel_estimation(PHY_VARS_gNB *gNB,
 
     // Local init in the current loop
     rdata->Ns = Ns;
-    rdata->nl = nl;
     rdata->p = p;
     rdata->symbol = symbol;
     rdata->aarx = job_id * numAntennas;
@@ -579,13 +577,14 @@ int nr_pusch_channel_estimation(PHY_VARS_gNB *gNB,
     rdata->delay = &delay_arr[rdata->aarx];
     rdata->beam_nb = beam_nb;
     rdata->frame_parms = fp;
-    rdata->pusch_vars = &gNB->pusch_vars[ul_id];
     rdata->chest_freq = gNB->chest_freq;
     rdata->rxdataF = gNB->common_vars.rxdataF;
     rdata->scope = gNB->scopeData;
     rdata->ans = &ans;
     rdata->pusch_ch_est_dmrs_pos_slot_mem = pusch_ch_est_dmrs_pos_slot_mem;
     rdata->dmrs_symbol_start_idx = dmrs_symbol_start_idx;
+    rdata->ul_ch_estimates_sz = sz;
+    rdata->ul_ch_estimates = ul_ch_estim[0];
     // Call the nr_pusch_antenna_processing function
     if (job_id == num_jobs - 1) {
       // Run the last job inline

openair1/PHY/NR_ESTIMATION/nr_ul_estimation.h

@@ -36,7 +36,9 @@ int nr_pusch_channel_estimation(PHY_VARS_gNB *gNB,
                                 int *max_ch,
                                 uint32_t *nvar,
                                 c16_t *pusch_dmrs_slot_mem,
-                                c16_t *pusch_ch_est_dmrs_pos_slot_mem);
+                                c16_t *pusch_ch_est_dmrs_pos_slot_mem,
+                                int sz,
+                                c16_t ul_ch_estim[][sz]);
 
 void dump_nr_I0_stats(FILE *fd,PHY_VARS_gNB *gNB);
 

openair1/PHY/NR_REFSIG/dmrs_nr.c

@@ -235,78 +235,84 @@ int8_t get_valid_dmrs_idx_for_channel_est(uint16_t dmrs_symb_pos, uint8_t counte
 }
 
 /* perform averaging of channel estimates and store result in first symbol buffer */
-void nr_chest_time_domain_avg(NR_DL_FRAME_PARMS *frame_parms,
-                              int32_t **ch_estimates,
-                              uint8_t num_symbols,
-                              uint8_t start_symbol,
-                              uint16_t dmrs_bitmap,
-                              uint16_t num_rbs)
+void nr_chest_time_domain_avg(int nb_dmrs_symb, int nl, int nbRx, int sz, c16_t ch_estimates[nb_dmrs_symb][nl][nbRx][sz])
+
 {
-  simde__m128i *ul_ch128_0;
-  simde__m128i *ul_ch128_1;
-  int16_t *ul_ch16_0;
-  int total_symbols = start_symbol + num_symbols;
-  int num_dmrs_symb = count_bits64_with_mask(dmrs_bitmap, start_symbol, total_symbols);
-  int first_dmrs_symb = get_next_dmrs_symbol_in_slot(dmrs_bitmap, start_symbol, total_symbols);
-  AssertFatal(first_dmrs_symb > -1, "No DMRS symbol present in this slot\n");
-  for (int aarx = 0; aarx < frame_parms->nb_antennas_rx; aarx++) {
-    for (int symb = first_dmrs_symb+1; symb < total_symbols; symb++) {
-      ul_ch128_0 = (simde__m128i *)&ch_estimates[aarx][first_dmrs_symb*frame_parms->ofdm_symbol_size];
-      if ((dmrs_bitmap >> symb) & 0x01) {
-        ul_ch128_1 = (simde__m128i *)&ch_estimates[aarx][symb*frame_parms->ofdm_symbol_size];
-        for (int rbIdx = 0; rbIdx < num_rbs; rbIdx++) {
-          ul_ch128_0[0] = simde_mm_adds_epi16(ul_ch128_0[0], ul_ch128_1[0]);
-          ul_ch128_0[1] = simde_mm_adds_epi16(ul_ch128_0[1], ul_ch128_1[1]);
-          ul_ch128_0[2] = simde_mm_adds_epi16(ul_ch128_0[2], ul_ch128_1[2]);
-          ul_ch128_0 += 3;
-          ul_ch128_1 += 3;
+  AssertFatal((nb_dmrs_symb < 5) && (nb_dmrs_symb > 0), "Illegal number of DMRS symbols in the slot\n");
+  for (int aarx = 0; aarx < nbRx; aarx++) {
+    simde__m128i *ul_ch128_0 = (simde__m128i *)ch_estimates[0][0][aarx];
+    for (int symb = 1; symb < nb_dmrs_symb; symb++) {
+      simde__m128i *toadd = (simde__m128i *)ch_estimates[symb][0][aarx];
+      // we do 4 REs in a 128 bit vector
+      for (int re = 0; re < sz / 4; re++)
+        ul_ch128_0[re] = simde_mm_adds_epi16(ul_ch128_0[re], *toadd++);
+    }
+    switch (nb_dmrs_symb) {
+      case 2: {
+        for (int re = 0; re < sz / 4; re++)
+          ul_ch128_0[re] = simde_mm_srai_epi16(ul_ch128_0[re], 1);
+      } break;
+      case 4: {
+        for (int re = 0; re < sz / 4; re++)
+          ul_ch128_0[re] = simde_mm_srai_epi16(ul_ch128_0[re], 2);
+      } break;
+      case 3: {
+        c16_t *todiv = (c16_t *)ul_ch128_0;
+        for (int re = 0; re < sz; re++) {
+          *todiv = (c16_t){todiv->r / 3, todiv->i / 3};
+          todiv++;
+        }
+      }
+    }
+  }
+}
+
+void nr_chest_time_domain_avg_ue(NR_DL_FRAME_PARMS *frame_parms,
+                                 int nl,
+                                 int nbRx,
+                                 int sz,
+                                 c16_t ch_estimates[][nl][nbRx][sz],
+                                 uint8_t num_symbols,
+                                 uint8_t start_symbol,
+                                 uint16_t dmrs_bitmap,
+                                 uint16_t num_rbs)
+{
+  const int total_symbols = start_symbol + num_symbols;
+  const int num_dmrs_symb = count_bits64_with_mask(dmrs_bitmap, start_symbol, total_symbols);
+  const int first_dmrs_symb = get_next_dmrs_symbol_in_slot(dmrs_bitmap, start_symbol, total_symbols);
+  AssertFatal(first_dmrs_symb > -1, "No DMRS symbol present in this slot\n");
+  AssertFatal((num_dmrs_symb < 5) && (num_dmrs_symb > 0), "Illegal number of DMRS symbols in the slot\n");
+  for (int aarx = 0; aarx < frame_parms->nb_antennas_rx; aarx++) {
+    simde__m128i *ul_ch128_0 = (simde__m128i *)ch_estimates[first_dmrs_symb][0][aarx];
+    for (int symb = first_dmrs_symb + 1; symb < total_symbols; symb++) {
+      if ((dmrs_bitmap >> symb) & 0x01) {
+        simde__m128i *toadd = (simde__m128i *)ch_estimates[symb][0][aarx];
+        simde__m128i *sumup = ul_ch128_0;
+        // one rb is 12 re, we do 4 REs in a 128 bit vector
+        for (int re = 0; re < num_rbs * 3; re++)
+          sumup[re] = simde_mm_adds_epi16(sumup[re], *toadd++);
+      }
+    }
+    switch (num_dmrs_symb) {
+      case 2: {
+        simde__m128i *todiv = ul_ch128_0;
+        for (int re = 0; re < num_rbs * 3; re++)
+          todiv[re] = simde_mm_srai_epi16(todiv[re], 1);
+      } break;
+      case 4: {
+        simde__m128i *todiv = ul_ch128_0;
+        for (int re = 0; re < num_rbs * 3; re++)
+          todiv[re] = simde_mm_srai_epi16(todiv[re], 2);
+      } break;
+      case 3: {
+        int16_t *todiv = (int16_t *)ul_ch128_0;
+        for (int rb = 0; rb < num_rbs; rb++) {
+          for (int i = 0; i < 24; i++) { // 12 REs real and imaginary
+            *todiv = *todiv / 3;
+            todiv++;
+          }
         }
       }
     }
-    ul_ch128_0 = (simde__m128i *)&ch_estimates[aarx][first_dmrs_symb*frame_parms->ofdm_symbol_size];
-    if (num_dmrs_symb == 2) {
-      for (int rbIdx = 0; rbIdx < num_rbs; rbIdx++) {
-        ul_ch128_0[0] = simde_mm_srai_epi16(ul_ch128_0[0], 1);
-        ul_ch128_0[1] = simde_mm_srai_epi16(ul_ch128_0[1], 1);
-        ul_ch128_0[2] = simde_mm_srai_epi16(ul_ch128_0[2], 1);
-        ul_ch128_0 += 3;
-      }
-    } else if (num_dmrs_symb == 4) {
-      for (int rbIdx = 0; rbIdx < num_rbs; rbIdx++) {
-        ul_ch128_0[0] = simde_mm_srai_epi16(ul_ch128_0[0], 2);
-        ul_ch128_0[1] = simde_mm_srai_epi16(ul_ch128_0[1], 2);
-        ul_ch128_0[2] = simde_mm_srai_epi16(ul_ch128_0[2], 2);
-        ul_ch128_0 += 3;
-      }
-    } else if (num_dmrs_symb == 3) {
-      ul_ch16_0 = (int16_t *)&ch_estimates[aarx][first_dmrs_symb*frame_parms->ofdm_symbol_size];
-      for (int rbIdx = 0; rbIdx < num_rbs; rbIdx++) {
-        ul_ch16_0[0] /= 3;
-        ul_ch16_0[1] /= 3;
-        ul_ch16_0[2] /= 3;
-        ul_ch16_0[3] /= 3;
-        ul_ch16_0[4] /= 3;
-        ul_ch16_0[5] /= 3;
-        ul_ch16_0[6] /= 3;
-        ul_ch16_0[7] /= 3;
-        ul_ch16_0[8] /= 3;
-        ul_ch16_0[9] /= 3;
-        ul_ch16_0[10] /= 3;
-        ul_ch16_0[11] /= 3;
-        ul_ch16_0[12] /= 3;
-        ul_ch16_0[13] /= 3;
-        ul_ch16_0[14] /= 3;
-        ul_ch16_0[15] /= 3;
-        ul_ch16_0[16] /= 3;
-        ul_ch16_0[17] /= 3;
-        ul_ch16_0[18] /= 3;
-        ul_ch16_0[19] /= 3;
-        ul_ch16_0[20] /= 3;
-        ul_ch16_0[21] /= 3;
-        ul_ch16_0[22] /= 3;
-        ul_ch16_0[23] /= 3;
-        ul_ch16_0 += 24;
-      }
-    } else AssertFatal((num_dmrs_symb < 5) && (num_dmrs_symb > 0), "Illegal number of DMRS symbols in the slot\n");
   }
 }

openair1/PHY/NR_REFSIG/dmrs_nr.h

@@ -32,13 +32,16 @@ uint8_t allowed_xlsch_re_in_dmrs_symbol(uint16_t k,
 void nr_gen_ref_conj_symbols(const uint32_t *in, uint32_t length, int16_t *output, int mod_order);
 int8_t get_next_dmrs_symbol_in_slot(uint16_t  ul_dmrs_symb_pos, uint8_t counter, uint8_t end_symbol);
 int8_t get_valid_dmrs_idx_for_channel_est(uint16_t  dmrs_symb_pos, uint8_t counter);
-void nr_chest_time_domain_avg(NR_DL_FRAME_PARMS *frame_parms,
-                              int32_t **ch_estimates,
-                              uint8_t num_symbols,
-                              uint8_t start_symbol,
-                              uint16_t dmrs_bitmap,
-                              uint16_t num_rbs);
-
+void nr_chest_time_domain_avg(int nb_dmrs_symb, int nl, int nbRx, int sz, c16_t ch_estimates[nb_dmrs_symb][nl][nbRx][sz]);
+void nr_chest_time_domain_avg_ue(NR_DL_FRAME_PARMS *frame_parms,
+                                 int nl,
+                                 int nbRx,
+                                 int sz,
+                                 c16_t ch_estimates[][nl][nbRx][sz],
+                                 uint8_t num_symbols,
+                                 uint8_t start_symbol,
+                                 uint16_t dmrs_bitmap,
+                                 uint16_t num_rbs);
 int8_t get_num_dmrs_re_per_rb(const uint8_t dmrs_type, const uint8_t num_cdm_grp_no_data);
 
 static inline uint8_t is_dmrs_symbol(uint8_t l, uint16_t dmrsSymbMask)

openair1/PHY/NR_TRANSPORT/nr_transport_proto.h

@@ -98,17 +98,13 @@ int nr_rx_pusch_tp(PHY_VARS_gNB *gNB, uint8_t ulsch_id, uint32_t frame, uint8_t
 */
 void nr_idft(int32_t *z, uint32_t Msc_PUSCH);
 
-void nr_ulsch_qpsk_qpsk(c16_t *stream0_in, 
-                        c16_t *stream1_in, 
-                        c16_t *stream0_out, 
-                        c16_t *rho01, 
-                        uint32_t length);
+void nr_ulsch_qpsk_qpsk(c16_t *stream0_in, c16_t *stream1_in, int16_t *stream0_out, c16_t *rho01, uint32_t length);
 
 void nr_ulsch_qam16_qam16(c16_t *stream0_in,
                           c16_t *stream1_in,
                           c16_t *ch_mag,
                           c16_t *ch_mag_i,
-                          c16_t *stream0_out,
+                          int16_t *stream0_out,
                           c16_t *rho01,
                           uint32_t length);
 
@@ -116,7 +112,7 @@ void nr_ulsch_qam64_qam64(c16_t *stream0_in,
                           c16_t *stream1_in,
                           c16_t *ch_mag,
                           c16_t *ch_mag_i,
-                          c16_t *stream0_out,
+                          int16_t *stream0_out,
                           c16_t *rho01,
                           uint32_t length);
 
@@ -152,8 +148,6 @@ void nr_ulsch_compute_ML_llr(c16_t *rxdataF_comp0,
                              uint32_t nb_re,
                              uint8_t mod_order);
 
-void nr_ulsch_shift_llr(int16_t **llr_layers, uint32_t nb_re, uint32_t rxdataF_ext_offset, uint8_t mod_order, int shift);
-
 void nr_fill_ulsch(PHY_VARS_gNB *gNB,
                    int frame,
                    int slot,

openair1/PHY/NR_TRANSPORT/nr_ulsch_demodulation.c

@@ -73,25 +73,19 @@ void nr_idft(int32_t *z, uint32_t Msc_PUSCH)
   }
 }
 
-static void nr_ulsch_extract_rbs(c16_t* const rxdataF,
-                                 c16_t* const chF,
-                                 c16_t *rxFext,
-                                 c16_t *chFext,
-                                 int rxoffset,
-                                 int choffset,
-                                 int is_dmrs_symbol,
+static void nr_ulsch_extract_rbs(const c16_t *const rxF,
+                                 const c16_t *const ul_ch0,
+                                 c16_t *rxF_ext,
+                                 c16_t *ul_ch0_ext,
+                                 const int is_dmrs_symbol,
                                  nfapi_nr_pusch_pdu_t *pusch_pdu,
-                                 NR_DL_FRAME_PARMS *frame_parms)
+                                 const NR_DL_FRAME_PARMS *frame_parms)
 {
   uint8_t delta = 0;
   int start_re = (frame_parms->first_carrier_offset + (pusch_pdu->rb_start + pusch_pdu->bwp_start) * NR_NB_SC_PER_RB)%frame_parms->ofdm_symbol_size;
   int nb_re_pusch = NR_NB_SC_PER_RB * pusch_pdu->rb_size;
-  c16_t *rxF = &rxdataF[rxoffset];
-  c16_t *rxF_ext = &rxFext[0];
-  c16_t *ul_ch0 = &chF[choffset];
-  c16_t *ul_ch0_ext = &chFext[0];
 
-  if (is_dmrs_symbol == 0) {
+  if (is_dmrs_symbol == false) {
     if (start_re + nb_re_pusch <= frame_parms->ofdm_symbol_size)
       memcpy(rxF_ext, &rxF[start_re], nb_re_pusch * sizeof(c16_t));
     else {
@@ -101,10 +95,9 @@ static void nr_ulsch_extract_rbs(c16_t* const rxdataF,
       memcpy(&rxF_ext[neg_length], rxF, pos_length * sizeof(c16_t));
     }
     memcpy(ul_ch0_ext, ul_ch0, nb_re_pusch * sizeof(c16_t));
-  }
-  else if (pusch_pdu->dmrs_config_type == pusch_dmrs_type1) { // 6 REs / PRB
+  } else if (pusch_pdu->dmrs_config_type == pusch_dmrs_type1) { // 6 REs / PRB
     AssertFatal(delta == 0 || delta == 1, "Illegal delta %d\n",delta);
-    c16_t *rxF32 = &rxF[start_re];
+    const c16_t *rxF32 = &rxF[start_re];
     if (start_re + nb_re_pusch < frame_parms->ofdm_symbol_size) {
       for (int idx = 1 - delta; idx < nb_re_pusch; idx += 2) {
         *rxF_ext++ = rxF32[idx];
@@ -126,8 +119,7 @@ static void nr_ulsch_extract_rbs(c16_t* const rxdataF,
         *ul_ch0_ext++ = ul_ch0[idx2];
       }
     }
-  }
-  else if (pusch_pdu->dmrs_config_type == pusch_dmrs_type2) { // 8 REs / PRB
+  } else if (pusch_pdu->dmrs_config_type == pusch_dmrs_type2) { // 8 REs / PRB
     AssertFatal(delta==0||delta==2||delta==4,"Illegal delta %d\n",delta);
     if (start_re + nb_re_pusch < frame_parms->ofdm_symbol_size) {
       for (int idx = 0; idx < nb_re_pusch; idx ++) {
@@ -140,7 +132,7 @@ static void nr_ulsch_extract_rbs(c16_t* const rxdataF,
     else {
       int neg_length = frame_parms->ofdm_symbol_size - start_re;
       int pos_length = nb_re_pusch - neg_length;
-      c16_t *rxF64 = &rxF[start_re];
+      const c16_t *rxF64 = &rxF[start_re];
       int idx, idx2;
       for (idx = 0; idx < neg_length; idx ++) {
         if (idx % 6 == 2 * delta || idx % 6 == 2 * delta + 1)
@@ -165,15 +157,15 @@ static int get_nb_re_pusch (NR_DL_FRAME_PARMS *frame_parms, nfapi_nr_pusch_pdu_t
   uint8_t dmrs_symbol_flag = (rel15_ul->ul_dmrs_symb_pos >> symbol) & 0x01;
   if (dmrs_symbol_flag == 1) {
     if ((rel15_ul->ul_dmrs_symb_pos >> ((symbol + 1) % frame_parms->symbols_per_slot)) & 0x01)
-      AssertFatal(1==0,"Double DMRS configuration is not yet supported\n");
-
+      AssertFatal(1 == 0, "Double DMRS configuration is not yet supported\n");
     if (rel15_ul->dmrs_config_type == 0) {
       // if no data in dmrs cdm group is 1 only even REs have no data
       // if no data in dmrs cdm group is 2 both odd and even REs have no data
       return(rel15_ul->rb_size *(12 - (rel15_ul->num_dmrs_cdm_grps_no_data*6)));
-    }
-    else return(rel15_ul->rb_size *(12 - (rel15_ul->num_dmrs_cdm_grps_no_data*4)));
-  } else return(rel15_ul->rb_size * NR_NB_SC_PER_RB);
+    } else
+      return (rel15_ul->rb_size * (12 - (rel15_ul->num_dmrs_cdm_grps_no_data * 4)));
+  } else
+    return (rel15_ul->rb_size * NR_NB_SC_PER_RB);
 }
 
 static void nr_ulsch_channel_compensation(uint32_t buffer_length,
@@ -865,12 +857,19 @@ static void inner_rx(PHY_VARS_gNB *gNB,
                      c16_t **rxF,
                      int16_t **llr,
                      int soffset,
+                     int *length,
                      int symbol,
                      int output_shift,
                      uint32_t nvar,
                      c16_t *rxFext_slot,
-                     c16_t *chFext_slot)
+                     c16_t *chFext_slot,
+                     int nbTx,
+                     int nbRx,
+                     int sz,
+                     int *dmrs_symb_pos,
+                     void *estimates)
 {
+  c16_t(*ul_ch_estimates)[nbTx][nbRx][sz] = (c16_t(*)[nbTx][nbRx][sz])estimates;
   int nb_layer = rel15_ul->nrOfLayers;
   int nb_rx_ant = frame_parms->nb_antennas_rx;
   int dmrs_symbol_flag = (rel15_ul->ul_dmrs_symb_pos >> symbol) & 0x01;
@@ -882,21 +881,17 @@ static void inner_rx(PHY_VARS_gNB *gNB,
   memset(chFext, 0, sizeof(chFext));
   int dmrs_symbol;
   if (gNB->chest_time == 0)
-    dmrs_symbol = dmrs_symbol_flag ? symbol : get_valid_dmrs_idx_for_channel_est(rel15_ul->ul_dmrs_symb_pos, symbol);
-  else { // average of channel estimates stored in first symbol
-    int end_symbol = rel15_ul->start_symbol_index + rel15_ul->nr_of_symbols;
-    dmrs_symbol = get_next_dmrs_symbol_in_slot(rel15_ul->ul_dmrs_symb_pos, rel15_ul->start_symbol_index, end_symbol);
-  }
+    dmrs_symbol = dmrs_symb_pos[dmrs_symbol_flag ? symbol : get_valid_dmrs_idx_for_channel_est(rel15_ul->ul_dmrs_symb_pos, symbol)];
+  else  // average of channel estimates stored in first symbol
+    dmrs_symbol = 0;
 
   for (int aarx = 0; aarx < nb_rx_ant; aarx++) {
     for (int aatx = 0; aatx < nb_layer; aatx++) {
-      nr_ulsch_extract_rbs(rxF[aarx],
-                           (c16_t *)pusch_vars->ul_ch_estimates[aatx * nb_rx_ant + aarx],
+      nr_ulsch_extract_rbs(rxF[aarx] + soffset + symbol * frame_parms->ofdm_symbol_size,
+                           ul_ch_estimates[dmrs_symbol][aatx][aarx],
                            rxFext[aarx],
                            chFext[aatx][aarx],
-                           soffset+(symbol * frame_parms->ofdm_symbol_size),
-                           dmrs_symbol * frame_parms->ofdm_symbol_size,
-                           dmrs_symbol_flag, 
+                           dmrs_symbol_flag,
                            rel15_ul,
                            frame_parms);
 #if T_TRACER
@@ -944,9 +939,9 @@ static void inner_rx(PHY_VARS_gNB *gNB,
                            rxF_ch_maga[0],
                            rxF_ch_magb[0],
                            symbol,
-                           pusch_vars->ul_valid_re_per_slot[symbol],
+                           *length,
                            rel15_ul->qam_mod_order);
-    nr_idft((int32_t *)&pusch_vars->rxdataF_comp[0][symbol * buffer_length], pusch_vars->ul_valid_re_per_slot[symbol]);
+    nr_idft((int32_t *)&pusch_vars->rxdataF_comp[0][symbol * buffer_length], *length);
   }
   if (rel15_ul->pdu_bit_map & PUSCH_PDU_BITMAP_PUSCH_PTRS) {
     nr_pusch_ptrs_processing(gNB,
@@ -956,20 +951,20 @@ static void inner_rx(PHY_VARS_gNB *gNB,
                              slot,
                              symbol,
                              buffer_length);
-    pusch_vars->ul_valid_re_per_slot[symbol] -= pusch_vars->ptrs_re_per_slot;
+    *length -= pusch_vars->ptrs_re_per_slot;
   }
 
   if (nb_layer == 2) {
     if (rel15_ul->qam_mod_order <= 6) {
-      nr_ulsch_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],
+      nr_ulsch_compute_ML_llr(&pusch_vars->rxdataF_comp[0][symbol * buffer_length],
+                              &pusch_vars->rxdataF_comp[nb_rx_ant][symbol * buffer_length],
                               rxF_ch_maga[0],
                               rxF_ch_maga[1],
                               llr[0],
                               llr[1],
                               rho[0][1],
                               rho[1][0],
-                              pusch_vars->ul_valid_re_per_slot[symbol],
+                              *length,
                               rel15_ul->qam_mod_order);
     }
     else {
@@ -984,7 +979,7 @@ static void inner_rx(PHY_VARS_gNB *gNB,
                             rel15_ul->qam_mod_order,
                             pusch_vars->log2_maxh,
                             symbol,
-                            pusch_vars->ul_valid_re_per_slot[symbol],
+                            *length,
                             nvar);
     }
   }
@@ -995,7 +990,7 @@ static void inner_rx(PHY_VARS_gNB *gNB,
                            rxF_ch_magb[aatx],
                            rxF_ch_magc[aatx],
                            llr[aatx],
-                           pusch_vars->ul_valid_re_per_slot[symbol],
+                           *length,
                            symbol,
                            rel15_ul->qam_mod_order);
 }
@@ -1015,6 +1010,13 @@ typedef struct puschSymbolProc_s {
   task_ans_t *ans;
   c16_t *pusch_ch_est_dmrs_interpl_slot_mem;
   c16_t *rxFext_slot_mem;
+  int nbTx;
+  int nbRx;
+  int sz;
+  int *dmrs_symb_pos;
+  c16_t *ul_ch_estimates;
+  int *ul_valid_re_per_slot;
+  int *llr_offset;
 } puschSymbolProc_t;
 
 static void nr_pusch_symbol_processing(void *arg)
@@ -1028,10 +1030,10 @@ static void nr_pusch_symbol_processing(void *arg)
   int slot = rdata->slot;
   NR_gNB_PUSCH *pusch_vars = &gNB->pusch_vars[ulsch_id];
   for (int symbol = rdata->startSymbol; symbol < rdata->startSymbol + rdata->numSymbols; symbol++) {
-    if (gNB->pusch_vars[ulsch_id].ul_valid_re_per_slot[symbol] == 0) 
+    if (rdata->ul_valid_re_per_slot[symbol] == 0)
       continue;
     int soffset = (slot % RU_RX_SLOT_DEPTH) * frame_parms->symbols_per_slot * frame_parms->ofdm_symbol_size;
-    int buffer_length = ceil_mod(pusch_vars->ul_valid_re_per_slot[symbol] * NR_NB_SC_PER_RB, 16);
+    int buffer_length = ceil_mod(rdata->ul_valid_re_per_slot[symbol] * NR_NB_SC_PER_RB, 16);
     int16_t llrs[rel15_ul->nrOfLayers][ceil_mod(buffer_length * rel15_ul->qam_mod_order, 64)];
     int16_t *llrss[rel15_ul->nrOfLayers];
     for (int l = 0; l < rel15_ul->nrOfLayers; l++)
@@ -1046,26 +1048,31 @@ static void nr_pusch_symbol_processing(void *arg)
              gNB->common_vars.rxdataF[rdata->beam_nb],
              llrss,
              soffset,
+             rdata->ul_valid_re_per_slot + symbol,
              symbol,
              gNB->pusch_vars[ulsch_id].log2_maxh,
              rdata->nvar,
              rdata->rxFext_slot_mem,
-             rdata->pusch_ch_est_dmrs_interpl_slot_mem);
-
-    int nb_re_pusch = gNB->pusch_vars[ulsch_id].ul_valid_re_per_slot[symbol];
+             rdata->pusch_ch_est_dmrs_interpl_slot_mem,
+             rdata->nbTx,
+             rdata->nbRx,
+             rdata->sz,
+             rdata->dmrs_symb_pos,
+             rdata->ul_ch_estimates);
+    int nb_re_pusch = rdata->ul_valid_re_per_slot[symbol];
     // layer de-mapping
     int16_t *llr_ptr = llrs[0];
     if (rel15_ul->nrOfLayers != 1) {
-      llr_ptr = &rdata->llr[pusch_vars->llr_offset[symbol] * rel15_ul->nrOfLayers];
-      for (int i = 0; i < (nb_re_pusch); i++)
+      llr_ptr = &rdata->llr[rdata->llr_offset[symbol] * rel15_ul->nrOfLayers];
+      for (int i = 0; i < nb_re_pusch; i++)
         for (int l = 0; l < rel15_ul->nrOfLayers; l++)
           for (int m = 0; m < rel15_ul->qam_mod_order; m++)
             llr_ptr[i * rel15_ul->nrOfLayers * rel15_ul->qam_mod_order + l * rel15_ul->qam_mod_order + m] =
                 llrss[l][i * rel15_ul->qam_mod_order + m];
     }
     // unscrambling
-    int16_t *llr16 = (int16_t*)&rdata->llr[pusch_vars->llr_offset[symbol] * rel15_ul->nrOfLayers];
-    int16_t *s = rdata->scramblingSequence + pusch_vars->llr_offset[symbol] * rel15_ul->nrOfLayers;
+    int16_t *llr16 = (int16_t *)&rdata->llr[rdata->llr_offset[symbol] * rel15_ul->nrOfLayers];
+    int16_t *s = rdata->scramblingSequence + rdata->llr_offset[symbol] * rel15_ul->nrOfLayers;
     const int end = nb_re_pusch * rel15_ul->qam_mod_order * rel15_ul->nrOfLayers;
     for (int i = 0; i < end; i++)
       llr16[i] = llr_ptr[i] * s[i];
@@ -1109,20 +1116,21 @@ int nr_rx_pusch_tp(PHY_VARS_gNB *gNB, uint8_t ulsch_id, uint32_t frame, uint8_t
   LOG_D(PHY,"pusch %d.%d : ul_dmrs_symb_pos %x\n",frame,slot,rel15_ul->ul_dmrs_symb_pos);
 
   // Memories to store data for data recording
-  int buffer_length_slot = rel15_ul->rb_size * NR_NB_SC_PER_RB * 14; // 14 OFDM Symbols per slot
-  int nb_rx_ant = frame_parms->nb_antennas_rx;
-  int nb_layer = rel15_ul->nrOfLayers;
-
-  // Initialize memory for DMRS signals
-  c16_t pusch_dmrs_slot_mem[nb_layer * buffer_length_slot] __attribute__((aligned(32)));
-  // Initialize memory for channel estimates based on DMRS positions
-  c16_t pusch_ch_est_dmrs_pos_slot_mem[buffer_length_slot * nb_layer * nb_rx_ant] __attribute__((aligned(32)));
-  // memory to store slot grid with channel coefficients based on DMRS positions after interpolation
-  c16_t pusch_ch_est_dmrs_interpl_slot_mem[buffer_length_slot * nb_layer * nb_rx_ant] __attribute__((aligned(32)));
-  // memory to store extracted data including PUSCH + DMRS
-  c16_t rxFext_slot_mem[nb_rx_ant * buffer_length_slot] __attribute__((aligned(32)));
+  const int nb_rx_ant = frame_parms->nb_antennas_rx;
+  const int nb_layer = rel15_ul->nrOfLayers;
+  const int nb_re = rel15_ul->rb_size * NR_NB_SC_PER_RB;
 
 #if T_TRACER
+  int buffer_length_slot = nb_re * 14; // 14 OFDM Symbols per slot
+  // Initialize memory for DMRS signals
+  check_vla(c16_t pusch_dmrs_slot_mem[nb_layer * buffer_length_slot] __attribute__((aligned(32))));
+  // Initialize memory for channel estimates based on DMRS positions
+  check_vla(c16_t pusch_ch_est_dmrs_pos_slot_mem[buffer_length_slot * nb_layer * nb_rx_ant] __attribute__((aligned(32))));
+  // memory to store slot grid with channel coefficients based on DMRS positions after interpolation
+  check_vla(c16_t pusch_ch_est_dmrs_interpl_slot_mem[buffer_length_slot * nb_layer * nb_rx_ant] __attribute__((aligned(32))));
+  // memory to store extracted data including PUSCH + DMRS
+  check_vla(c16_t rxFext_slot_mem[nb_rx_ant * buffer_length_slot] __attribute__((aligned(32))));
+
   // Initialize memory for DMRS signals
   if (T_ACTIVE(T_GNB_PHY_UL_FD_DMRS))
     memset(pusch_dmrs_slot_mem, 0, sizeof(c16_t) * nb_layer * buffer_length_slot);
@@ -1138,6 +1146,11 @@ int nr_rx_pusch_tp(PHY_VARS_gNB *gNB, uint8_t ulsch_id, uint32_t frame, uint8_t
   // memory to store extracted data including PUSCH + DMRS
   if (T_ACTIVE(T_GNB_PHY_UL_FD_PUSCH_IQ))
     memset(rxFext_slot_mem, 0, sizeof(c16_t) * buffer_length_slot * nb_rx_ant);
+#else
+  void *pusch_dmrs_slot_mem = NULL;
+  void *pusch_ch_est_dmrs_pos_slot_mem = NULL;
+  void *pusch_ch_est_dmrs_interpl_slot_mem = NULL;
+  void *rxFext_slot_mem = NULL;
 #endif
 
   //----------------------------------------------------------
@@ -1146,14 +1159,21 @@ int nr_rx_pusch_tp(PHY_VARS_gNB *gNB, uint8_t ulsch_id, uint32_t frame, uint8_t
   start_meas(&gNB->ulsch_channel_estimation_stats);
   int max_ch = 0;
   uint32_t nvar = 0;
-  int end_symbol = rel15_ul->start_symbol_index + rel15_ul->nr_of_symbols;
-  for (uint8_t symbol = rel15_ul->start_symbol_index; symbol < end_symbol; symbol++) {
-    uint8_t dmrs_symbol_flag = (rel15_ul->ul_dmrs_symb_pos >> symbol) & 0x01;
+  const int end_symbol = rel15_ul->start_symbol_index + rel15_ul->nr_of_symbols;
+  const int number_dmrs_symbols = count_bits64_with_mask(rel15_ul->ul_dmrs_symb_pos, rel15_ul->start_symbol_index, rel15_ul->nr_of_symbols);
+  const int reSz=ceil_mod(nb_re,16);
+  check_vla(c16_t ul_ch_estimates[number_dmrs_symbols][nb_layer][nb_rx_ant][reSz]);
+  memset( ul_ch_estimates,0, sizeof(ul_ch_estimates));//computation gets out the size
+  int dmrs_symb_pos[rel15_ul->start_symbol_index + rel15_ul->nr_of_symbols];
+  int dmrs_symb = 0;
+  for (int symbol = rel15_ul->start_symbol_index; symbol < end_symbol; symbol++) {
+    int dmrs_symbol_flag = (rel15_ul->ul_dmrs_symb_pos >> symbol) & 0x01;
     LOG_D(PHY, "symbol %d, dmrs_symbol_flag :%d\n", symbol, dmrs_symbol_flag);
-
     if (dmrs_symbol_flag == 1) {
+      dmrs_symb_pos[symbol] = dmrs_symb++;
       for (int nl = 0; nl < rel15_ul->nrOfLayers; nl++) {
         uint32_t nvar_tmp = 0;
+
         nr_pusch_channel_estimation(gNB,
                                     slot,
                                     nl,
@@ -1166,13 +1186,15 @@ int nr_rx_pusch_tp(PHY_VARS_gNB *gNB, uint8_t ulsch_id, uint32_t frame, uint8_t
                                     &max_ch,
                                     &nvar_tmp,
                                     pusch_dmrs_slot_mem,
-                                    pusch_ch_est_dmrs_pos_slot_mem);
+                                    pusch_ch_est_dmrs_pos_slot_mem,
+                                    nb_re,
+                                    ul_ch_estimates[dmrs_symb_pos[symbol]][nl]);
         nvar += nvar_tmp;
       }
     }
   }
 
-  nvar /= (rel15_ul->nr_of_symbols * rel15_ul->nrOfLayers * frame_parms->nb_antennas_rx);
+  nvar /= rel15_ul->nr_of_symbols * rel15_ul->nrOfLayers * frame_parms->nb_antennas_rx;
 
   allocCast2D(n0_subband_power,
               unsigned int,
@@ -1183,7 +1205,7 @@ int nr_rx_pusch_tp(PHY_VARS_gNB *gNB, uint8_t ulsch_id, uint32_t frame, uint8_t
 
   int start_sc = (rel15_ul->bwp_start + rel15_ul->rb_start) * NR_NB_SC_PER_RB;
   int middle_sc = frame_parms->ofdm_symbol_size - frame_parms->first_carrier_offset;
-  int end_sc = (start_sc + rel15_ul->rb_size * NR_NB_SC_PER_RB - 1) % frame_parms->ofdm_symbol_size;
+  int end_sc = (start_sc + nb_re - 1) % frame_parms->ofdm_symbol_size;
   for (int aarx = 0; aarx < frame_parms->nb_antennas_rx; aarx++) {
     pusch_vars->ulsch_power[aarx] = 0;
     pusch_vars->ulsch_noise_power[aarx] = 0;
@@ -1197,9 +1219,9 @@ int nr_rx_pusch_tp(PHY_VARS_gNB *gNB, uint8_t ulsch_id, uint32_t frame, uint8_t
         int64_t symb_energy_aux = signal_energy_nodc(ul_ch, middle_sc - start_sc) * (middle_sc - start_sc);
         ul_ch = &gNB->common_vars.rxdataF[beam_nb][aarx][offset0];
         symb_energy_aux += (signal_energy_nodc(ul_ch, end_sc + 1) * (end_sc + 1));
-        symb_energy += symb_energy_aux / (rel15_ul->rb_size * NR_NB_SC_PER_RB);
+        symb_energy += symb_energy_aux / nb_re;
       } else {
-        symb_energy += signal_energy_nodc(ul_ch, rel15_ul->rb_size * NR_NB_SC_PER_RB);
+        symb_energy += signal_energy_nodc(ul_ch, nb_re);
       }
     }
     pusch_vars->ulsch_power[aarx] += (symb_energy / rel15_ul->nr_of_symbols);
@@ -1219,26 +1241,14 @@ int nr_rx_pusch_tp(PHY_VARS_gNB *gNB, uint8_t ulsch_id, uint32_t frame, uint8_t
 
   // averaging time domain channel estimates
   if (gNB->chest_time == 1)
-    nr_chest_time_domain_avg(frame_parms,
-                             pusch_vars->ul_ch_estimates,
-                             rel15_ul->nr_of_symbols,
-                             rel15_ul->start_symbol_index,
-                             rel15_ul->ul_dmrs_symb_pos,
-                             rel15_ul->rb_size);
+    nr_chest_time_domain_avg(number_dmrs_symbols, nb_layer, nb_rx_ant, reSz, ul_ch_estimates);
 
   stop_meas(&gNB->ulsch_channel_estimation_stats);
 
   start_meas(&gNB->rx_pusch_init_stats);
 
   // Scrambling initialization
-  int number_dmrs_symbols = 0;
-  for (int l = rel15_ul->start_symbol_index; l < end_symbol; l++)
-    number_dmrs_symbols += ((rel15_ul->ul_dmrs_symb_pos)>>l) & 0x01;
-  int nb_re_dmrs;
-  if (rel15_ul->dmrs_config_type == pusch_dmrs_type1)
-    nb_re_dmrs = 6*rel15_ul->num_dmrs_cdm_grps_no_data;
-  else
-    nb_re_dmrs = 4*rel15_ul->num_dmrs_cdm_grps_no_data;
+  const int nb_re_dmrs = rel15_ul->num_dmrs_cdm_grps_no_data * (rel15_ul->dmrs_config_type == pusch_dmrs_type1 ? 6 : 4);
 
   uint32_t unav_res = 0;
   if (rel15_ul->pdu_bit_map & PUSCH_PDU_BITMAP_PUSCH_PTRS) {
@@ -1286,24 +1296,21 @@ int nr_rx_pusch_tp(PHY_VARS_gNB *gNB, uint8_t ulsch_id, uint32_t frame, uint8_t
 
   nb_re_pusch = ceil_mod(nb_re_pusch, 16);
   int dmrs_symbol;
+  
   if (gNB->chest_time == 0)
-    dmrs_symbol = get_valid_dmrs_idx_for_channel_est(rel15_ul->ul_dmrs_symb_pos, meas_symbol);
+    dmrs_symbol = dmrs_symb_pos[get_valid_dmrs_idx_for_channel_est(rel15_ul->ul_dmrs_symb_pos, meas_symbol)];
   else // average of channel estimates stored in first symbol
-    dmrs_symbol = get_next_dmrs_symbol_in_slot(rel15_ul->ul_dmrs_symb_pos, rel15_ul->start_symbol_index, end_symbol);
-  int size_est = nb_re_pusch * frame_parms->symbols_per_slot;
-  __attribute__((aligned(32))) int ul_ch_estimates_ext[rel15_ul->nrOfLayers * frame_parms->nb_antennas_rx][size_est];
-  memset(ul_ch_estimates_ext, 0, sizeof(ul_ch_estimates_ext));
-  int buffer_length = rel15_ul->rb_size * NR_NB_SC_PER_RB;
+    dmrs_symbol = 0;
+  check_vla(c16_t ul_ch_estimates_ext[number_dmrs_symbols][nb_layer][nb_rx_ant][nb_re]);
+  int buffer_length = nb_re;
   c16_t temp_rxFext[frame_parms->nb_antennas_rx][buffer_length] __attribute__((aligned(32)));
   for (int aarx = 0; aarx < frame_parms->nb_antennas_rx; aarx++) 
     for (int nl = 0; nl < rel15_ul->nrOfLayers; nl++)
-      nr_ulsch_extract_rbs(gNB->common_vars.rxdataF[beam_nb][aarx],
-                           (c16_t *)pusch_vars->ul_ch_estimates[nl * frame_parms->nb_antennas_rx + aarx],
+      nr_ulsch_extract_rbs(gNB->common_vars.rxdataF[beam_nb][aarx] + soffset + meas_symbol * frame_parms->ofdm_symbol_size,
+                           ul_ch_estimates[dmrs_symbol][nl][aarx],
                            temp_rxFext[aarx],
-                           (c16_t*)&ul_ch_estimates_ext[nl * frame_parms->nb_antennas_rx + aarx][meas_symbol * nb_re_pusch],
-                           soffset + meas_symbol * frame_parms->ofdm_symbol_size,
-                           dmrs_symbol * frame_parms->ofdm_symbol_size,
-                           (rel15_ul->ul_dmrs_symb_pos >> meas_symbol) & 0x01, 
+                           ul_ch_estimates_ext[dmrs_symbol][nl][aarx],
+                           (rel15_ul->ul_dmrs_symb_pos >> meas_symbol) & 0x01,
                            rel15_ul,
                            frame_parms);
 
@@ -1312,22 +1319,15 @@ int nr_rx_pusch_tp(PHY_VARS_gNB *gNB, uint8_t ulsch_id, uint32_t frame, uint8_t
   //----------------------------------------------------------
   //--------------------- Channel Scaling --------------------
   //----------------------------------------------------------
-  nr_scale_channel(size_est,
-                   ul_ch_estimates_ext,
-                   meas_symbol,
-                   nb_re_pusch,
-                   rel15_ul->nrOfLayers,
+  nr_scale_channel(rel15_ul->nrOfLayers,
                    frame_parms->nb_antennas_rx,
+                   nb_re,
+                   nb_re_pusch,
+                   ul_ch_estimates_ext[dmrs_symbol],
                    shift_ch_ext);
 
   int avg[frame_parms->nb_antennas_rx*rel15_ul->nrOfLayers];
-  nr_channel_level(meas_symbol,
-                   size_est,
-                   (c16_t (*)[size_est])ul_ch_estimates_ext,
-                   frame_parms->nb_antennas_rx,
-                   rel15_ul->nrOfLayers,
-                   avg,
-                   nb_re_pusch);
+  nr_channel_level(nb_layer, nb_rx_ant, nb_re, nb_re_pusch, ul_ch_estimates_ext[dmrs_symbol], avg);
 
   int avgs = 0;
   for (int nl = 0; nl < rel15_ul->nrOfLayers; nl++)
@@ -1353,46 +1353,52 @@ int nr_rx_pusch_tp(PHY_VARS_gNB *gNB, uint8_t ulsch_id, uint32_t frame, uint8_t
   puschSymbolProc_t arr[loop_iter];
   task_ans_t ans;
   init_task_ans(&ans, loop_iter);
-
   int sz_arr = 0;
+  int ul_valid_re_per_slot[14] = {};
+  int llr_offset[14] = {};
   for(uint8_t task_index = 0; task_index < loop_iter; task_index++) {
     int symbol = task_index * numSymbols + rel15_ul->start_symbol_index;
     int res_per_task = 0;
-    for (int s = 0; s < numSymbols && s + symbol < end_symbol; s++) {
-      pusch_vars->ul_valid_re_per_slot[symbol+s] = get_nb_re_pusch(frame_parms,rel15_ul,symbol+s);
-      pusch_vars->llr_offset[symbol+s] = ((symbol+s) == rel15_ul->start_symbol_index) ? 
-                                         0 : 
-                                         pusch_vars->llr_offset[symbol+s-1] + pusch_vars->ul_valid_re_per_slot[symbol+s-1] * rel15_ul->qam_mod_order;
-      res_per_task += pusch_vars->ul_valid_re_per_slot[symbol + s];
+    int local_numsymb = task_index == loop_iter - 1 ? end_symbol - symbol : numSymbols;
+    for (int s = symbol; s < symbol + local_numsymb; s++) {
+      ul_valid_re_per_slot[s] = get_nb_re_pusch(frame_parms, rel15_ul, s);
+      llr_offset[s] =
+          s == rel15_ul->start_symbol_index ? 0 : llr_offset[s - 1] + ul_valid_re_per_slot[s - 1] * rel15_ul->qam_mod_order;
+      res_per_task += ul_valid_re_per_slot[s];
     }
     total_res += res_per_task;
     if (res_per_task > 0) {
-      puschSymbolProc_t *rdata = &arr[sz_arr];
-      rdata->ans = &ans;
-      ++sz_arr;
-
-      rdata->gNB = gNB;
-      rdata->frame_parms = frame_parms;
-      rdata->rel15_ul = rel15_ul;
-      rdata->slot = slot;
-      rdata->startSymbol = symbol;
-      // Last task processes remainder symbols
-      rdata->numSymbols = task_index == loop_iter - 1 ? rel15_ul->nr_of_symbols - (loop_iter - 1) * numSymbols : numSymbols;
-      rdata->ulsch_id = ulsch_id;
-      rdata->llr = pusch_vars->llr;
-      rdata->scramblingSequence = scramblingSequence;
-      rdata->nvar = nvar;
-      rdata->beam_nb = beam_nb;
-      rdata->rxFext_slot_mem = rxFext_slot_mem;
-      rdata->pusch_ch_est_dmrs_interpl_slot_mem = pusch_ch_est_dmrs_interpl_slot_mem;
-
+      arr[sz_arr] = (puschSymbolProc_t){
+          .gNB = gNB,
+          .frame_parms = frame_parms,
+          .rel15_ul = rel15_ul,
+          .ulsch_id = ulsch_id,
+          .slot = slot,
+          .startSymbol = symbol,
+          // Last task processes remainder symbols
+          .numSymbols = local_numsymb,
+          .llr = pusch_vars->llr,
+          .scramblingSequence = scramblingSequence,
+          .nvar = nvar,
+          .beam_nb = beam_nb,
+          .ans = &ans,
+          .pusch_ch_est_dmrs_interpl_slot_mem = pusch_ch_est_dmrs_interpl_slot_mem,
+          .rxFext_slot_mem = rxFext_slot_mem,
+          .nbTx = nb_layer,
+          .nbRx = nb_rx_ant,
+          .sz = reSz,
+          .dmrs_symb_pos = dmrs_symb_pos,
+          .ul_ch_estimates = (void *)ul_ch_estimates,
+          .ul_valid_re_per_slot = ul_valid_re_per_slot,
+          .llr_offset = llr_offset,
+      };
       if (rel15_ul->pdu_bit_map & PUSCH_PDU_BITMAP_PUSCH_PTRS) {
-        nr_pusch_symbol_processing(rdata);
+        nr_pusch_symbol_processing(&arr[sz_arr]);
       } else {
-        task_t t = {.func = &nr_pusch_symbol_processing, .args = rdata};
+        task_t t = {.func = &nr_pusch_symbol_processing, .args = &arr[sz_arr]};
         pushTpool(&gNB->threadPool, t);
       }
-
+      sz_arr++;
       LOG_D(PHY, "%d.%d Added symbol %d to process, in pipe\n", frame, slot, symbol);
     } else {
       completed_task_ans(&ans);
@@ -1447,7 +1453,7 @@ int nr_rx_pusch_tp(PHY_VARS_gNB *gNB, uint8_t ulsch_id, uint32_t frame, uint8_t
       T_INT((int)rel15_ul->scid), // dmrs_nscid
       T_INT((int)frame_parms->nb_antennas_rx), // rx antenna
       T_INT(0), // number_of_bits
-      T_BUFFER((c16_t *)(&(pusch_dmrs_slot_mem[0])), rel15_ul->rb_size * NR_NB_SC_PER_RB * rel15_ul->nr_of_symbols * 4));
+      T_BUFFER((c16_t *)(&(pusch_dmrs_slot_mem[0])), nb_re * rel15_ul->nr_of_symbols * 4));
   }
 
   if (T_ACTIVE(T_GNB_PHY_UL_FD_CHAN_EST_DMRS_POS)) {
@@ -1490,7 +1496,7 @@ int nr_rx_pusch_tp(PHY_VARS_gNB *gNB, uint8_t ulsch_id, uint32_t frame, uint8_t
       T_INT((int)rel15_ul->scid), // dmrs_nscid
       T_INT((int)frame_parms->nb_antennas_rx), // rx antenna
       T_INT(0), // number_of_bits
-      T_BUFFER((c16_t *)(&(pusch_ch_est_dmrs_pos_slot_mem[0])), rel15_ul->rb_size * NR_NB_SC_PER_RB * rel15_ul->nr_of_symbols * 4));
+      T_BUFFER((c16_t *)(&(pusch_ch_est_dmrs_pos_slot_mem[0])), nb_re * rel15_ul->nr_of_symbols * 4));
   }
 
   if (T_ACTIVE(T_GNB_PHY_UL_FD_PUSCH_IQ)) {
@@ -1534,8 +1540,7 @@ int nr_rx_pusch_tp(PHY_VARS_gNB *gNB, uint8_t ulsch_id, uint32_t frame, uint8_t
       T_INT((int)rel15_ul->scid), // dmrs_nscid
       T_INT((int)frame_parms->nb_antennas_rx), // rx antenna
       T_INT(0), // number_of_bits
-      T_BUFFER((c16_t *)(&(rxFext_slot_mem[0])),
-               rel15_ul->rb_size * NR_NB_SC_PER_RB * rel15_ul->nr_of_symbols * frame_parms->nb_antennas_rx * 4));
+      T_BUFFER((c16_t *)(&(rxFext_slot_mem[0])), nb_re * rel15_ul->nr_of_symbols * frame_parms->nb_antennas_rx * 4));
   }
   if (T_ACTIVE(T_GNB_PHY_UL_FD_CHAN_EST_DMRS_INTERPL)) {
     // Log pusch_ch_est_dmrs_interpl_slot_mem using T-Tracer if activated
@@ -1578,9 +1583,8 @@ int nr_rx_pusch_tp(PHY_VARS_gNB *gNB, uint8_t ulsch_id, uint32_t frame, uint8_t
       T_INT((int)rel15_ul->scid), // dmrs_nscid
       T_INT((int)frame_parms->nb_antennas_rx), // rx antenna
       T_INT(0), // number_of_bits
-      T_BUFFER(
-          (c16_t *)pusch_ch_est_dmrs_interpl_slot_mem,
-          rel15_ul->rb_size * NR_NB_SC_PER_RB * rel15_ul->nr_of_symbols * frame_parms->nb_antennas_rx * rel15_ul->nrOfLayers * 4));
+      T_BUFFER((c16_t *)pusch_ch_est_dmrs_interpl_slot_mem,
+               nb_re * rel15_ul->nr_of_symbols * frame_parms->nb_antennas_rx * rel15_ul->nrOfLayers * 4));
   }
 #endif
 
@@ -1591,17 +1595,17 @@ int nr_rx_pusch_tp(PHY_VARS_gNB *gNB, uint8_t ulsch_id, uint32_t frame, uint8_t
   // buffer due to reference symbol extraction and padding. The gNBscopeCopy call is broken up into steps: trylock, copy, unlock.
   metadata mt = {.slot = slot, .frame = frame};
   if (gNBTryLockScopeData(gNB, gNBPuschRxIq, sizeof(c16_t), 1, total_res, &mt)) {
-    int buffer_length = ceil_mod(rel15_ul->rb_size * NR_NB_SC_PER_RB, 16);
+    int buffer_length = ceil_mod(nb_re, 16);
     size_t offset = 0;
     for (uint8_t symbol = rel15_ul->start_symbol_index; symbol < (rel15_ul->start_symbol_index + rel15_ul->nr_of_symbols);
          symbol++) {
       gNBscopeCopyUnsafe(gNB,
                          gNBPuschRxIq,
                          &pusch_vars->rxdataF_comp[0][symbol * buffer_length],
-                         sizeof(c16_t) * pusch_vars->ul_valid_re_per_slot[symbol],
+                         sizeof(c16_t) * ul_valid_re_per_slot[symbol],
                          offset,
                          symbol - rel15_ul->start_symbol_index);
-      offset += sizeof(c16_t) * pusch_vars->ul_valid_re_per_slot[symbol];
+      offset += sizeof(c16_t) * ul_valid_re_per_slot[symbol];
     }
     gNBunlockScopeData(gNB, gNBPuschRxIq)
   }

openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c

@@ -9,7 +9,7 @@
 #include "PHY/defs_gNB.h"
 #include "PHY/sse_intrin.h"
 #include "nr_phy_common.h"
-
+#include "openair1/PHY/NR_TRANSPORT/nr_transport_proto.h"
 #ifdef __aarch64__
 #define USE_128BIT
 #endif

openair1/PHY/NR_UE_ESTIMATION/nr_dl_channel_estimation.c

@@ -1241,7 +1241,7 @@ void nr_pdsch_channel_estimation(PHY_VARS_NR_UE *ue,
                                  unsigned short p,
                                  unsigned char symbol,
                                  uint32_t pdsch_est_size,
-                                 int32_t dl_ch_estimates[][pdsch_est_size],
+                                 c16_t dl_ch_estimates[][pdsch_est_size],
                                  int rxdataFsize,
                                  c16_t rxdataF[][rxdataFsize],
                                  uint32_t *nvar)
@@ -1249,7 +1249,6 @@ void nr_pdsch_channel_estimation(PHY_VARS_NR_UE *ue,
   // int gNB_id = proc->gNB_id;
   int slot = proc->nr_slot_rx;
   NR_DL_FRAME_PARMS *fp = &ue->frame_parms;
-  const int ch_offset = fp->ofdm_symbol_size * symbol;
   const int symbol_offset = fp->ofdm_symbol_size * symbol;
   int bwp_start_subcarrier = fp->first_carrier_offset + (dlsch->BWPStart + freq_alloc->start[0]) * 12;
 
@@ -1288,7 +1287,7 @@ void nr_pdsch_channel_estimation(PHY_VARS_NR_UE *ue,
 #endif
 
     c16_t *rxF = &rxdataF[aarx][symbol_offset + delta];
-    c16_t *dl_ch = (c16_t *)&dl_ch_estimates[nl * fp->nb_antennas_rx + aarx][ch_offset];
+    c16_t *dl_ch = dl_ch_estimates[aarx];
     memset(dl_ch, 0, sizeof(*dl_ch) * fp->ofdm_symbol_size);
 
     if (config_type == NFAPI_NR_DMRS_TYPE1 && ue->chest_freq == 0) {

openair1/PHY/NR_UE_ESTIMATION/nr_estimation.h

@@ -69,7 +69,7 @@ void nr_pdsch_channel_estimation(PHY_VARS_NR_UE *ue,
                                  unsigned short p,
                                  unsigned char symbol,
                                  uint32_t pdsch_est_size,
-                                 int32_t dl_ch_estimates[][pdsch_est_size],
+                                 c16_t dl_ch_estimates[][pdsch_est_size],
                                  int rxdataFsize,
                                  c16_t rxdataF[][rxdataFsize],
                                  uint32_t *nvar);
@@ -86,7 +86,7 @@ void nr_ue_measurements(PHY_VARS_NR_UE *ue,
                         const UE_nr_rxtx_proc_t *proc,
                         int number_rbs,
                         uint32_t pdsch_est_size,
-                        int32_t dl_ch_estimates[][pdsch_est_size]);
+                        c16_t dl_ch_estimates[][pdsch_est_size]);
 
 uint32_t nr_ue_calculate_ssb_rsrp(const NR_DL_FRAME_PARMS *fp,
                                   const c16_t rxdataF[][fp->samples_per_slot_wCP],

openair1/PHY/NR_UE_ESTIMATION/nr_ue_measurements.c

@@ -33,12 +33,11 @@ void nr_ue_measurements(PHY_VARS_NR_UE *ue,
                         const UE_nr_rxtx_proc_t *proc,
                         int number_rbs,
                         uint32_t pdsch_est_size,
-                        int32_t dl_ch_estimates[][pdsch_est_size])
+                        c16_t dl_ch_estimates[][pdsch_est_size])
 {
   int slot = proc->nr_slot_rx;
   int aarx, aatx, gNB_id = 0;
   NR_DL_FRAME_PARMS *frame_parms = &ue->frame_parms;
-  int ch_offset = frame_parms->ofdm_symbol_size*2;
   ue->measurements.nb_antennas_rx = frame_parms->nb_antennas_rx;
 
   allocCast3D(rx_spatial_power,
@@ -62,7 +61,7 @@ void nr_ue_measurements(PHY_VARS_NR_UE *ue,
     for (aarx = 0; aarx < frame_parms->nb_antennas_rx; aarx++) {
       int rx_power = 0;
       for (aatx = 0; aatx < frame_parms->nb_antenna_ports_gNB; aatx++) {
-        const int z = signal_energy_nodc((c16_t*)&dl_ch_estimates[gNB_id][ch_offset], number_rbs * NR_NB_SC_PER_RB);
+        const int z = signal_energy_nodc(dl_ch_estimates[aarx], number_rbs * NR_NB_SC_PER_RB);
         rx_spatial_power[gNB_id][aatx][aarx] = z;
         if (rx_spatial_power[gNB_id][aatx][aarx] < 0)
           rx_spatial_power[gNB_id][aatx][aarx] = 0;

openair1/PHY/NR_UE_TRANSPORT/dci_nr.c

@@ -358,7 +358,7 @@ static void nr_rx_pdcch_symbol(PHY_VARS_NR_UE *ue,
 
   LOG_D(NR_PHY_DCI, "in channel level function (dl_ch_estimates_ext -> dl_ch_estimates_ext)\n");
   int avg[fp->nb_antennas_rx];
-  nr_channel_level(0, rx_size, pdcch_dl_ch_estimates_ext, fp->nb_antennas_rx, 1, avg, n_rb * RE_PER_RB_OUT_DMRS);
+  nr_channel_level(1, fp->nb_antennas_rx, rx_size, n_rb * RE_PER_RB_OUT_DMRS, &pdcch_dl_ch_estimates_ext, avg);
   int avgs = avg[0];
   for (int i = 1; i < fp->nb_antennas_rx; i++)
       avgs = cmax(avgs, avg[i]);

openair1/PHY/NR_UE_TRANSPORT/nr_dlsch_demodulation.c

@@ -112,7 +112,7 @@ static void nr_dlsch_channel_compensation(uint32_t rx_size_symbol,
                                           int nbRx,
                                           uint8_t n_layers,
                                           c16_t rxdataF_ext[][rx_size_symbol],
-                                          int32_t dl_ch_estimates_ext[][rx_size_symbol],
+                                          c16_t dl_ch_estimates_ext[][nbRx][rx_size_symbol],
                                           c16_t dl_ch_mag[][nbRx][rx_size_symbol],
                                           c16_t dl_ch_magb[][nbRx][rx_size_symbol],
                                           c16_t dl_ch_magr[][nbRx][rx_size_symbol],
@@ -146,7 +146,7 @@ static void nr_dlsch_channel_compensation(uint32_t rx_size_symbol,
     }
 
     for (int aarx = 0; aarx < frame_parms->nb_antennas_rx; aarx++) {
-      dl_ch128 = (simde__m128i *)dl_ch_estimates_ext[(l * frame_parms->nb_antennas_rx) + aarx];
+      dl_ch128 = (simde__m128i *)dl_ch_estimates_ext[l][aarx];
       dl_ch_mag128 = (simde__m128i *)dl_ch_mag[l][aarx];
       dl_ch_mag128b = (simde__m128i *)dl_ch_magb[l][aarx];
       dl_ch_mag128r = (simde__m128i *)dl_ch_magr[l][aarx];
@@ -219,8 +219,8 @@ static void nr_dlsch_channel_compensation(uint32_t rx_size_symbol,
       for (int l = 0; l < n_layers; l++) {
         for (int atx = 0; atx < n_layers; atx++) {
           rho128 = (simde__m128i *)&rho[aarx][l * n_layers + atx][symbol * nb_rb * 12];
-          dl_ch128 = (simde__m128i *)dl_ch_estimates_ext[l * frame_parms->nb_antennas_rx + aarx];
-          dl_ch128_2 = (simde__m128i *)dl_ch_estimates_ext[atx * frame_parms->nb_antennas_rx + aarx];
+          dl_ch128 = (simde__m128i *)dl_ch_estimates_ext[l][aarx];
+          dl_ch128_2 = (simde__m128i *)dl_ch_estimates_ext[atx][aarx];
           // multiply by conjugated channel
           mult_cpx_conj_vector((c16_t *)dl_ch128, (c16_t *)dl_ch128_2, (c16_t *)rho128, 12 * nb_rb_0, output_shift);
         }
@@ -229,18 +229,18 @@ static void nr_dlsch_channel_compensation(uint32_t rx_size_symbol,
   }
 }
 
-static void nr_dlsch_channel_level_median(uint32_t rx_size_symbol,
-                                          int32_t dl_ch_estimates_ext[][rx_size_symbol],
-                                          int32_t median[MAX_ANT][MAX_ANT],
-                                          int n_tx,
+static void nr_dlsch_channel_level_median(int n_tx,
                                           int n_rx,
+                                          uint32_t rx_size_symbol,
+                                          c16_t dl_ch_estimates_ext[n_tx][n_rx][rx_size_symbol],
+                                          int32_t median[MAX_ANT][MAX_ANT],
                                           int length)
 {
   for (int aatx = 0; aatx < n_tx; aatx++) {
     for (int aarx = 0; aarx < n_rx; aarx++) {
       int64_t max = median[aatx][aarx]; // initialize the med point for max
       int64_t min = median[aatx][aarx]; // initialize the med point for min
-      simde__m128i *dl_ch128 = (simde__m128i *)dl_ch_estimates_ext[aatx * n_rx + aarx];
+      simde__m128i *dl_ch128 = (simde__m128i *)dl_ch_estimates_ext[aatx][aarx];
 
       const int length2 = length >> 2; // length = number of REs, hence length2=nb_REs*(32/128) in SIMD loop
 
@@ -270,17 +270,18 @@ static void nr_dlsch_channel_level_median(uint32_t rx_size_symbol,
 static void nr_dlsch_extract_rbs(uint32_t rxdataF_sz,
                                  c16_t rxdataF[][rxdataF_sz],
                                  uint32_t rx_size_symbol,
+                                 uint8_t Nl,
+                                 int nbRx,
                                  uint32_t pdsch_est_size,
-                                 int32_t dl_ch_estimates[][pdsch_est_size],
+                                 c16_t dl_ch_estimates[][Nl][nbRx][pdsch_est_size],
                                  c16_t rxdataF_ext[][rx_size_symbol],
-                                 int32_t dl_ch_estimates_ext[][rx_size_symbol],
+                                 c16_t dl_ch_estimates_ext[Nl][nbRx][rx_size_symbol],
                                  unsigned char symbol,
                                  uint8_t pilots,
                                  uint8_t config_type,
                                  int startBWP,
                                  const freq_alloc_bitmap_t *freq_alloc,
                                  uint8_t n_dmrs_cdm_groups,
-                                 uint8_t Nl,
                                  NR_DL_FRAME_PARMS *fp,
                                  uint16_t dlDmrsSymbPos,
                                  uint32_t csi_res_bitmap,
@@ -324,8 +325,8 @@ static void nr_dlsch_extract_rbs(uint32_t rxdataF_sz,
       c16_t *rxF_ext = rxdataF_ext[aarx];
       c16_t *rxF = &rxdataF[aarx][symbol * fp->ofdm_symbol_size];
       for (int l = 0; l < Nl; l++) {
-        int32_t *dl_ch0 = &dl_ch_estimates[(l * fp->nb_antennas_rx) + aarx][validDmrsEst * fp->ofdm_symbol_size];
-        int32_t *dl_ch0_ext = dl_ch_estimates_ext[(l * fp->nb_antennas_rx) + aarx];
+        c16_t *dl_ch0 = dl_ch_estimates[validDmrsEst][l][aarx];
+        c16_t *dl_ch0_ext = dl_ch_estimates_ext[l][aarx];
         if (pilots == 0 && csi_res_bitmap == 0) { // data symbol only
           if (l == 0) {
             if (start_re + nb_rb * NR_NB_SC_PER_RB <= fp->ofdm_symbol_size) {
@@ -699,7 +700,7 @@ static void nr_dlsch_mmse(uint32_t rx_size_symbol,
                           c16_t dl_ch_mag[][n_rx][rx_size_symbol],
                           c16_t dl_ch_magb[][n_rx][rx_size_symbol],
                           c16_t dl_ch_magr[][n_rx][rx_size_symbol],
-                          int32_t dl_ch_estimates_ext[][rx_size_symbol],
+                          c16_t dl_ch_estimates_ext[nl][n_rx][rx_size_symbol],
                           unsigned char mod_order,
                           int shift,
                           unsigned char symbol,
@@ -722,8 +723,8 @@ static void nr_dlsch_mmse(uint32_t rx_size_symbol,
   for (int rtx = 0; rtx < nl; rtx++) {//row
     for (int ctx = 0; ctx < nl; ctx++) {//column
       for (int aarx = 0; aarx < n_rx; aarx++)  {
-        c16_t *ch0r = (c16_t *)dl_ch_estimates_ext[rtx * n_rx + aarx];
-        c16_t *ch0c = (c16_t *)dl_ch_estimates_ext[ctx * n_rx + aarx];
+        c16_t *ch0r = dl_ch_estimates_ext[rtx][aarx];
+        c16_t *ch0c = dl_ch_estimates_ext[ctx][aarx];
         nr_conjch0_mult_ch1(ch0r,
                             ch0c,
                             conjH_H_elements[aarx][ctx][rtx], // sic
@@ -940,14 +941,15 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
                 unsigned char symbol,
                 bool first_symbol_flag,
                 unsigned char harq_pid,
+                uint8_t Nl,
+                int nbRx,
                 uint32_t pdsch_est_size,
-                int32_t dl_ch_estimates[][pdsch_est_size],
+                c16_t dl_ch_estimates[][Nl][nbRx][pdsch_est_size],
                 int16_t *llr[2],
                 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,
-                int nbRx,
                 c16_t rxdataF_comp[][dlsch->Nl][nbRx][rx_size_symbol],
                 c16_t dl_ch_mag[][dlsch->Nl][nbRx][rx_size_symbol],
                 c16_t dl_ch_magb[][dlsch->Nl][nbRx][rx_size_symbol],
@@ -960,9 +962,7 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
 {
   NR_DL_FRAME_PARMS *fp = &ue->frame_parms;
   const int nl = dlsch[0].Nl;
-  const int n_rx = fp->nb_antennas_rx;
-  const int matrixSz = n_rx * nl;
-  __attribute__((aligned(32))) int32_t dl_ch_estimates_ext[matrixSz][rx_size_symbol];
+  __attribute__((aligned(32))) c16_t dl_ch_estimates_ext[nl][nbRx][rx_size_symbol];
   memset(dl_ch_estimates_ext, 0, sizeof(dl_ch_estimates_ext));
 
   NR_UE_COMMON *common_vars  = &ue->common_vars;
@@ -1066,10 +1066,11 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
     uint32_t csi_res_bitmap = build_csi_overlap_bitmap(dlsch_config, symbol);
 
     LOG_D(PHY, "%d.%d symbol %d csi overlap bitmap %d\n", frame, nr_slot_rx, symbol, csi_res_bitmap);
-
     nr_dlsch_extract_rbs(fp->samples_per_slot_wCP,
                          rxdataF,
                          rx_size_symbol,
+                         Nl,
+                         nbRx,
                          pdsch_est_size,
                          dl_ch_estimates,
                          rxdataF_ext,
@@ -1080,7 +1081,6 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
                          dlsch_config->BWPStart,
                          freq_alloc,
                          dlsch_config->n_dmrs_cdm_groups,
-                         nl,
                          fp,
                          dlsch_config->dlDmrsSymbPos,
                          csi_res_bitmap,
@@ -1090,7 +1090,7 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
       size_t size = sizeof(c16_t) * nb_rb_pdsch * NR_NB_SC_PER_RB;
       int copy_index = symbol - dlsch_config->start_symbol;
       int offset = copy_index * size;
-      UEscopeCopyUnsafe(ue, pdschChanEstimates, dl_ch_estimates_ext[0], size, offset, copy_index);
+      UEscopeCopyUnsafe(ue, pdschChanEstimates, dl_ch_estimates_ext[0][0], size, offset, copy_index);
     }
     if (meas_enabled) {
       LOG_D(PHY,
@@ -1142,7 +1142,8 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
     //--------------------- Channel Scaling --------------------
     //----------------------------------------------------------
     start_meas_nr_ue_phy(ue, DLSCH_CHANNEL_SCALE_STATS);
-    nr_scale_channel(rx_size_symbol, dl_ch_estimates_ext, 0, nb_re_pdsch, nl, n_rx, 0);
+    // Fixme: scale by 0 ?
+    // nr_scale_channel(nl, nbRx, rx_size_symbol,nb_re_pdsch, dl_ch_estimates_ext,0);
     stop_meas_nr_ue_phy(ue, DLSCH_CHANNEL_SCALE_STATS);
     if (meas_enabled) {
       LOG_D(PHY,
@@ -1159,24 +1160,24 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
     //----------------------------------------------------------
     start_meas_nr_ue_phy(ue, DLSCH_CHANNEL_LEVEL_STATS);
     if (first_symbol_flag) {
-      int32_t avg[nl * n_rx];
+      int32_t avg[nl * nbRx];
       if (nb_re_pdsch)
-        nr_channel_level(0, rx_size_symbol, (c16_t (*)[rx_size_symbol])dl_ch_estimates_ext, n_rx, nl, avg, nb_re_pdsch);
+        nr_channel_level(nl, nbRx, rx_size_symbol, nb_re_pdsch, dl_ch_estimates_ext, avg);
       else
         LOG_E(NR_PHY, "Average channel level is 0: nb_rb_pdsch = %d, nb_re_pdsch = %d\n", nb_rb_pdsch, nb_re_pdsch);
       int avgs = 0;
       int32_t median[MAX_ANT][MAX_ANT];
       for (int l = 0; l < nl; l++)
-        for (int aarx = 0; aarx < n_rx; aarx++) {
-          avgs = cmax(avgs, avg[l * n_rx + aarx]);
-          LOG_D(PHY, "nb_rb %d avg_%d_%d Power per SC is %d\n", nb_rb_pdsch, aarx, l, avg[l * n_rx + aarx]);
+        for (int aarx = 0; aarx < nbRx; aarx++) {
+          avgs = cmax(avgs, avg[l * nbRx + aarx]);
+          LOG_D(PHY, "nb_rb %d avg_%d_%d Power per SC is %d\n", nb_rb_pdsch, aarx, l, avg[l * nbRx + aarx]);
           LOG_D(PHY, "avgs Power per SC is %d\n", avgs);
-          median[l][aarx] = avg[l * n_rx + aarx];
+          median[l][aarx] = avg[l * nbRx + aarx];
         }
       if (nl > 1) {
-        nr_dlsch_channel_level_median(rx_size_symbol, dl_ch_estimates_ext, median, nl, n_rx, nb_re_pdsch);
+        nr_dlsch_channel_level_median(nl, nbRx, rx_size_symbol, dl_ch_estimates_ext, median, nb_re_pdsch);
         for (int l = 0; l < nl; l++) {
-          for (int aarx = 0; aarx < n_rx; aarx++) {
+          for (int aarx = 0; aarx < nbRx; aarx++) {
             avgs = cmax(avgs, median[l][aarx]);
           }
         }
@@ -1189,9 +1190,9 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
         T_INT(frame % 1024),
         T_INT(nr_slot_rx),
         T_INT(avg[0]), // layer 0, antenna 0
-        T_INT(n_rx > 1 ? avg[1] : 0), // layer 0, antenna 1
-        T_INT(nl > 1 ? avg[n_rx] : 0), // layer 1, antenna 0
-        T_INT(nl > 1 && n_rx > 1 ? avg[n_rx + 1] : 0)); // layer 1, antenna 1
+        T_INT(nbRx > 1 ? avg[1] : 0), // layer 0, antenna 1
+        T_INT(nl > 1 ? avg[nbRx] : 0), // layer 1, antenna 0
+        T_INT(nl > 1 && nbRx > 1 ? avg[nbRx + 1] : 0)); // layer 1, antenna 1
 #endif
     }
     stop_meas_nr_ue_phy(ue, DLSCH_CHANNEL_LEVEL_STATS);
@@ -1260,10 +1261,10 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
   }
 
   start_meas_nr_ue_phy(ue, DLSCH_MRC_MMSE_STATS);
-  if (n_rx > 1) {
+  if (nbRx > 1) {
     nr_dlsch_detection_mrc(rx_size_symbol,
                            nl,
-                           n_rx,
+                           nbRx,
                            rxdataF_comp,
                            NULL,
                            dl_ch_mag[symbol],
@@ -1274,7 +1275,7 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
     if (nl >= 2) // Apply MMSE for 2, 3, and 4 Tx layers
       if (nb_re_pdsch)
         nr_dlsch_mmse(rx_size_symbol,
-                      n_rx,
+                      nbRx,
                       nl,
                       rxdataF_comp,
                       dl_ch_mag[symbol],
@@ -1347,7 +1348,7 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
                    dl_ch_mag[llr_sym][0][0],
                    dl_ch_magb[llr_sym][0][0],
                    dl_ch_magr[llr_sym][0][0],
-                   n_rx,
+                   nbRx,
                    rxdataF_comp[llr_sym],
                    llr_per_symbol,
                    layer_llr[llr_sym]);

openair1/PHY/NR_UE_TRANSPORT/nr_pbch.c

@@ -319,14 +319,14 @@ int nr_rx_pbch(PHY_VARS_NR_UE *ue,
   for (symbol=1; symbol<4; symbol++) {
     const uint16_t nb_re=symbol == 2 ? 72 : 180;
     __attribute__ ((aligned(32))) struct complex16 rxdataF_ext[frame_parms->nb_antennas_rx][PBCH_MAX_RE_PER_SYMBOL];
-    __attribute__ ((aligned(32))) struct complex16 dl_ch_estimates_ext[frame_parms->nb_antennas_rx][PBCH_MAX_RE_PER_SYMBOL];
+    __attribute__((aligned(32))) struct complex16 dl_ch_estimates_ext[1][frame_parms->nb_antennas_rx][PBCH_MAX_RE_PER_SYMBOL];
     memset(dl_ch_estimates_ext,0, sizeof  dl_ch_estimates_ext);
     nr_pbch_extract(frame_parms->samples_per_slot_wCP,
                     rxdataF,
                     estimateSz,
                     dl_ch_estimates,
                     rxdataF_ext,
-                    dl_ch_estimates_ext,
+                    dl_ch_estimates_ext[0],
                     symbol,
                     symbol_offset,
                     ssb_start_subcarrier,
@@ -340,7 +340,7 @@ int nr_rx_pbch(PHY_VARS_NR_UE *ue,
     int max_h = 0;
     if (symbol == 1) {
       int avg[frame_parms->nb_antennas_rx];
-      nr_channel_level(0, PBCH_MAX_RE_PER_SYMBOL, dl_ch_estimates_ext, frame_parms->nb_antennas_rx, 1, avg, nb_re);
+      nr_channel_level(1, frame_parms->nb_antennas_rx, PBCH_MAX_RE_PER_SYMBOL, nb_re, dl_ch_estimates_ext, avg);
       max_h = avg[0];
       for (int i = 1; i < frame_parms->nb_antennas_rx; i++)
         max_h = cmax(avg[i], max_h);
@@ -352,7 +352,7 @@ int nr_rx_pbch(PHY_VARS_NR_UE *ue,
 #endif
     __attribute__ ((aligned(32))) struct complex16 rxdataF_comp[frame_parms->nb_antennas_rx][PBCH_MAX_RE_PER_SYMBOL];
     nr_pbch_channel_compensation(rxdataF_ext,
-                                 dl_ch_estimates_ext,
+                                 dl_ch_estimates_ext[0],
                                  nb_re,
                                  rxdataF_comp,
                                  frame_parms,

openair1/PHY/NR_UE_TRANSPORT/nr_psbch_rx.c

@@ -125,15 +125,15 @@ int nr_rx_psbch(PHY_VARS_NR_UE *ue,
 
   for (int symbol = 0; symbol < numsym;) {
     const uint16_t nb_re = SL_NR_NUM_PSBCH_DATA_RE_IN_ONE_SYMBOL;
-    __attribute__((aligned(32))) struct complex16 rxdataF_ext[frame_parms->nb_antennas_rx][nb_re + 1];
-    __attribute__((aligned(32))) struct complex16 dl_ch_estimates_ext[frame_parms->nb_antennas_rx][nb_re + 1];
+    __attribute__((aligned(32))) c16_t rxdataF_ext[frame_parms->nb_antennas_rx][nb_re + 1];
+    __attribute__((aligned(32))) c16_t dl_ch_estimates_ext[1][frame_parms->nb_antennas_rx][nb_re + 1];
     // memset(dl_ch_estimates_ext,0, sizeof  dl_ch_estimates_ext);
     nr_psbch_extract(frame_parms->samples_per_slot_wCP,
                      rxdataF,
                      estimateSz,
                      dl_ch_estimates,
                      rxdataF_ext,
-                     dl_ch_estimates_ext,
+                     dl_ch_estimates_ext[0],
                      symbol,
                      frame_parms);
 #ifdef DEBUG_PSBCH
@@ -143,7 +143,7 @@ int nr_rx_psbch(PHY_VARS_NR_UE *ue,
     int max_h = 0;
     if (symbol == 0) {
       int avg[frame_parms->nb_antennas_rx];
-      nr_channel_level(0, PBCH_MAX_RE_PER_SYMBOL, dl_ch_estimates_ext, frame_parms->nb_antennas_rx, 1, avg, nb_re);
+      nr_channel_level(1, frame_parms->nb_antennas_rx, nb_re + 1, nb_re, dl_ch_estimates_ext, avg);
       max_h = avg[0];
       for (int i = 1; i < frame_parms->nb_antennas_rx; i++)
         max_h = cmax(avg[i], max_h);
@@ -155,7 +155,7 @@ int nr_rx_psbch(PHY_VARS_NR_UE *ue,
 
     __attribute__((aligned(32))) struct complex16 rxdataF_comp[frame_parms->nb_antennas_rx][nb_re + 1];
     nr_pbch_channel_compensation(rxdataF_ext,
-                                 dl_ch_estimates_ext,
+                                 dl_ch_estimates_ext[0],
                                  nb_re,
                                  rxdataF_comp,
                                  frame_parms,

openair1/PHY/NR_UE_TRANSPORT/nr_transport_proto_ue.h

@@ -281,14 +281,15 @@ int nr_rx_pdsch(PHY_VARS_NR_UE *ue,
                 unsigned char symbol,
                 bool first_symbol_flag,
                 unsigned char harq_pid,
+                uint8_t Nl,
+                int nbRx,
                 uint32_t pdsch_est_size,
-                int32_t dl_ch_estimates[][pdsch_est_size],
+                c16_t dl_ch_estimates[][Nl][nbRx][pdsch_est_size],
                 int16_t *llr[2],
                 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,
-                int nbRx,
                 c16_t rxdataF_comp[][dlsch->Nl][nbRx][rx_size_symbol],
                 c16_t dl_ch_mag[][dlsch->Nl][nbRx][rx_size_symbol],
                 c16_t dl_ch_magb[][dlsch->Nl][nbRx][rx_size_symbol],

openair1/PHY/defs_gNB.h

@@ -237,10 +237,6 @@ typedef struct {
 } NR_gNB_COMMON;
 
 typedef struct {
-  /// \brief Hold the channel estimates in frequency domain based on DRS.
-  /// - first index: rx antenna id [0..nb_antennas_rx[
-  /// - second index: ? [0..12*N_RB_UL*frame_parms->symbols_per_tti[
-  int32_t **ul_ch_estimates;
   /// \brief Holds the compensated signal.
   /// - first index: rx antenna id [0..nb_antennas_rx[
   /// - second index: ? [0..12*N_RB_UL*frame_parms->symbols_per_tti[
@@ -268,11 +264,6 @@ typedef struct {
   /// - first index: ? [0..7] Number of Antenna
   /// - second index: ? [0...14] smybol per slot
   int32_t **ptrs_phase_per_slot;
-  /// \brief Total RE count after DMRS/PTRS RE's are extracted from respective symbol.
-  /// - first index: ? [0...14] smybol per slot
-  int16_t *ul_valid_re_per_slot;
-  /// \brief offset for llr corresponding to each symbol
-  int llr_offset[14];
   /// flag to indicate DTX on reception
   int DTX;
 } NR_gNB_PUSCH;

openair1/PHY/nr_phy_common/inc/nr_phy_common.h

@@ -340,14 +340,18 @@ void freq2time(uint16_t ofdm_symbol_size, int16_t *freq_signal, int16_t *time_si
 void nr_est_delay(int ofdm_symbol_size, const c16_t *ls_est, c16_t *ch_estimates_time, delay_t *delay);
 unsigned int nr_get_tx_amp(int power_dBm, int power_max_dBm, int total_nb_rb, int nb_rb);
 void nr_fo_compensation(double fo_Hz, int samples_per_ms, int sample_offset, const c16_t *rxdata_in, c16_t *rxdata_out, int size);
-void nr_channel_level(const int symbol,
-                      const int size_est,
-                      const c16_t ch_estimates_ext[][size_est],
+void nr_channel_level(const int Nl,
                       const int nb_rx,
-                      const int Nl,
-                      int32_t avg[nb_rx * Nl],
-                      const uint32_t len);
-void nr_scale_channel(int size, int ch_estimates_ext[][size], int symb, uint32_t len, int nrOfLayers, int nb_rx, int shift_ch_ext);
+                      const int size,
+                      const uint32_t len,
+                      const c16_t ch_estimates_ext[Nl][nb_rx][size],
+                      int32_t avg[nb_rx * Nl]);
+void nr_scale_channel(int nrOfLayers,
+                      int nb_rx,
+                      int size,
+                      int len,
+                      c16_t ch_estimates_ext[nrOfLayers][nb_rx][size],
+                      int shift_ch_ext);
 bool generate_srs_nr(const NR_DL_FRAME_PARMS *frame_parms,
                      c16_t **txdataF,
                      uint16_t symbol_offset,

openair1/PHY/nr_phy_common/src/nr_phy_common.c

@@ -388,19 +388,18 @@ unsigned int nr_get_tx_amp(int power_dBm, int power_max_dBm, int total_nb_rb, in
 }
 
 // compute average channel_level on each antenna
-void nr_channel_level(const int symbol,
-                      const int size_est,
-                      const c16_t ch_estimates_ext[][size_est],
+void nr_channel_level(const int Nl,
                       const int nb_rx,
-                      const int Nl,
-                      int32_t avg[nb_rx * Nl],
-                      const uint32_t len)
+                      const int size,
+                      const uint32_t len,
+                      const c16_t ch_estimates_ext[Nl][nb_rx][size],
+                      int32_t avg[nb_rx * Nl])
 {
   int16_t x = factor2(len);
   int16_t y = len >> x;
   for (int aarx = 0; aarx < nb_rx; aarx++) {
     for (int l = 0; l < Nl; l++) {
-      simde__m128i *ch128 = (simde__m128i *)&ch_estimates_ext[l * nb_rx + aarx][symbol * len];
+      simde__m128i *ch128 = (simde__m128i *)ch_estimates_ext[l][aarx];
       //compute average level
       avg[l * nb_rx + aarx] = simde_mm_average(ch128, len, x, y);
       LOG_D(PHY, "Channel level: %d\n", avg[l * nb_rx + aarx]);
@@ -408,11 +407,16 @@ void nr_channel_level(const int symbol,
   }
 }
 
-void nr_scale_channel(int size, int ch_estimates_ext[][size], int symb, uint32_t len, int nrOfLayers, int nb_rx, int shift_ch_ext)
+void nr_scale_channel(int nrOfLayers,
+                      int nb_rx,
+                      int size,
+                      int len,
+                      c16_t ch_estimates_ext[nrOfLayers][nb_rx][size],
+                      int shift_ch_ext)
 {
   for (int l = 0; l < nrOfLayers; l++) {
     for (int aarx = 0; aarx < nb_rx; aarx++) {
-      simde__m128i *ul_ch128 = (simde__m128i *)&ch_estimates_ext[l * nb_rx + aarx][symb * len];
+      simde__m128i *ul_ch128 = (simde__m128i *)ch_estimates_ext[l][aarx];
       int loop_end = len >> 2;
       for (int i = 0; i < loop_end; i++) {
         ul_ch128[i] = simde_mm_srai_epi16(ul_ch128[i], shift_ch_ext);

openair1/SCHED_NR/phy_procedures_nr_gNB.c

@@ -1070,7 +1070,7 @@ int phy_procedures_gNB_uespec_RX(PHY_VARS_gNB *gNB, int frame_rx, int slot_rx, N
   UL_INFO->rx_ind.sfn = frame_rx;
   UL_INFO->rx_ind.slot = slot_rx;
   UL_INFO->rx_ind.pdu_list = UL_INFO->rx_pdu_list;
-  bool ulsch_to_decode[gNB->max_nb_pusch];
+  check_vla(bool ulsch_to_decode[gNB->max_nb_pusch]);
   bzero(ulsch_to_decode, sizeof(ulsch_to_decode));
   for (int ULSCH_id = 0; ULSCH_id < gNB->max_nb_pusch; ULSCH_id++) {
     NR_gNB_ULSCH_t *ulsch = &gNB->ulsch[ULSCH_id];

openair1/SCHED_NR_UE/phy_procedures_nr_ue.c

@@ -398,7 +398,7 @@ static void nr_ue_measurement_procedures(uint16_t l,
                                          const UE_nr_rxtx_proc_t *proc,
                                          int number_rbs,
                                          uint32_t pdsch_est_size,
-                                         int32_t dl_ch_estimates[][pdsch_est_size])
+                                         c16_t dl_ch_estimates[][pdsch_est_size])
 {
   NR_DL_FRAME_PARMS *frame_parms=&ue->frame_parms;
   int nr_slot_rx = proc->nr_slot_rx;
@@ -428,12 +428,10 @@ static void nr_ue_measurement_procedures(uint16_t l,
   }
 
   // accumulate and filter timing offset estimation every subframe (instead of every frame)
-  if (( nr_slot_rx == 2) && (l==(2-frame_parms->Ncp))) {
-
+  if ((nr_slot_rx == 2) && (l == (2 - frame_parms->Ncp))) {
     // AGC
     //printf("start adjust gain power avg db %d\n", ue->measurements.rx_power_avg_dB[gNB_id]);
-    phy_adjust_gain_nr (ue,ue->measurements.rx_power_avg_dB[gNB_id],gNB_id);
-    
+    phy_adjust_gain_nr(ue, ue->measurements.rx_power_avg_dB[gNB_id], gNB_id);
   }
 }
 
@@ -581,9 +579,16 @@ static int nr_ue_pdsch_procedures(PHY_VARS_NR_UE *ue,
         dlschCfg->dlDmrsSymbPos,
         dlsch0->Nl);
 
-  const uint32_t pdsch_est_size = ((ue->frame_parms.symbols_per_slot * ue->frame_parms.ofdm_symbol_size + 15) / 16) * 16;
+  const uint32_t pdsch_est_size = ((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 * dlsch0->Nl, pdsch_est_size, false);
+  allocCast4D(pdsch_dl_ch_estimates,
+              c16_t,
+              toFree,
+              ue->frame_parms.symbols_per_slot,
+              dlsch0->Nl,
+              ue->frame_parms.nb_antennas_rx,
+              pdsch_est_size,
+              false);
 
   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));
@@ -618,7 +623,7 @@ static int nr_ue_pdsch_procedures(PHY_VARS_NR_UE *ue,
                                     get_dmrs_port(nl, dlschCfg->dmrs_ports),
                                     m,
                                     pdsch_est_size,
-                                    pdsch_dl_ch_estimates,
+                                    pdsch_dl_ch_estimates[m][nl],
                                     ue->frame_parms.samples_per_slot_wCP,
                                     rxdataF,
                                     &nvar_tmp);
@@ -637,15 +642,23 @@ static int nr_ue_pdsch_procedures(PHY_VARS_NR_UE *ue,
   }
   stop_meas_nr_ue_phy(ue, DLSCH_CHANNEL_ESTIMATION_STATS);
   nvar /= (dlschCfg->number_symbols * dlsch0->Nl * ue->frame_parms.nb_antennas_rx);
-  nr_ue_measurement_procedures(2, ue, proc, freq_alloc.num_rbs, pdsch_est_size, pdsch_dl_ch_estimates);
+  int first_dmrs;
+  for (first_dmrs = dlschCfg->start_symbol; first_dmrs < dlschCfg->start_symbol + dlschCfg->number_symbols; first_dmrs++)
+    if (dlschCfg->dlDmrsSymbPos & (1 << first_dmrs))
+      break;
+  if (first_dmrs != dlschCfg->start_symbol + dlschCfg->number_symbols)
+    nr_ue_measurement_procedures(2, ue, proc, freq_alloc.num_rbs, pdsch_est_size, pdsch_dl_ch_estimates[first_dmrs][0]);
 
   if (ue->chest_time == 1) { // averaging time domain channel estimates
-    nr_chest_time_domain_avg(&ue->frame_parms,
-                             (int32_t **)pdsch_dl_ch_estimates,
-                             dlschCfg->number_symbols,
-                             dlschCfg->start_symbol,
-                             dlschCfg->dlDmrsSymbPos,
-                             freq_alloc.num_rbs);
+    nr_chest_time_domain_avg_ue(&ue->frame_parms,
+                                dlsch[0].Nl,
+                                ue->frame_parms.nb_antennas_rx,
+                                pdsch_est_size,
+                                pdsch_dl_ch_estimates,
+                                dlschCfg->number_symbols,
+                                dlschCfg->start_symbol,
+                                dlschCfg->dlDmrsSymbPos,
+                                freq_alloc.num_rbs);
   }
 
   uint16_t first_symbol_with_data = dlschCfg->start_symbol;
@@ -715,6 +728,7 @@ static int nr_ue_pdsch_procedures(PHY_VARS_NR_UE *ue,
 
     // process DLSCH received symbols in the slot
     // symbol by symbol processing (if data/DMRS are multiplexed is checked inside the function)
+
     if (nr_rx_pdsch(ue,
                     proc,
                     dlsch,
@@ -722,6 +736,8 @@ static int nr_ue_pdsch_procedures(PHY_VARS_NR_UE *ue,
                     m,
                     first_symbol_flag,
                     harq_pid,
+                    dlsch0->Nl,
+                    ue->frame_parms.nb_antennas_rx,
                     pdsch_est_size,
                     pdsch_dl_ch_estimates,
                     llr,
@@ -729,7 +745,6 @@ static int nr_ue_pdsch_procedures(PHY_VARS_NR_UE *ue,
                     rxdataF,
                     &log2_maxh,
                     rx_size_symbol,
-                    ue->frame_parms.nb_antennas_rx,
                     rxdataF_comp,
                     dl_ch_mag,
                     dl_ch_magb,

openair1/SIMULATION/NR_PHY/ulsim.c

@@ -264,7 +264,7 @@ int main(int argc, char *argv[])
   stop = false;
   __attribute__((unused)) struct sigaction oldaction;
   sigaction(SIGINT, &sigint_action, &oldaction);
-
+  printf("Origin stack: %lu\n", get_stack_usage());
   FILE *csv_file = NULL;
   char *filename_csv = NULL;
   int i;
@@ -288,7 +288,6 @@ int main(int argc, char *argv[])
   uint16_t N_RB_DL = 106, N_RB_UL = 106, mu = 1;
 
   // unsigned char frame_type = 0;
-  int loglvl = OAILOG_WARNING;
   uint16_t nb_symb_sch = 12;
   int start_symbol = 0;
   uint16_t nb_rb = 50;
@@ -342,7 +341,7 @@ int main(int argc, char *argv[])
     exit_fun("[NR_ULSIM] Error, configuration module init failed\n");
   }
   int ul_proc_error = 0; // uplink processing checking status flag
-  //logInit();
+  logInit();
   randominit();
 
   /* initialize the sin-cos table */
@@ -594,7 +593,7 @@ int main(int argc, char *argv[])
       break;
 
     case 'L':
-      loglvl = atoi(optarg);
+      set_glog(atoi(optarg));
       break;
 
    case 'T':
@@ -706,9 +705,6 @@ int main(int argc, char *argv[])
     }
   }
 
-  logInit();
-  set_glog(loglvl);
-
   get_softmodem_params()->phy_test = 1;
   get_softmodem_params()->do_ra = 0;
 
@@ -1598,13 +1594,6 @@ int main(int argc, char *argv[])
         if (n_trials == 1 && round == 0) {
           __attribute__((unused)) int off = ((nb_rb & 1) == 1) ? 4 : 0;
 
-          LOG_M("chestF0.m",
-                "chF0",
-                &pusch_vars->ul_ch_estimates[0][start_symbol * gNB->frame_parms.ofdm_symbol_size],
-                gNB->frame_parms.ofdm_symbol_size,
-                1,
-                1 | log_format);
-
           LOG_M("rxsigF0_comp.m",
                 "rxsF0_comp",
                 &pusch_vars->rxdataF_comp[0][start_symbol * (off + (NR_NB_SC_PER_RB * pusch_pdu->rb_size))],
@@ -1613,13 +1602,6 @@ int main(int argc, char *argv[])
                 1 | log_format);
 
           if (precod_nbr_layers == 2) {
-            LOG_M("chestF3.m",
-                  "chF3",
-                  &pusch_vars->ul_ch_estimates[3][start_symbol * gNB->frame_parms.ofdm_symbol_size],
-                  gNB->frame_parms.ofdm_symbol_size,
-                  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))],
@@ -1629,25 +1611,6 @@ int main(int argc, char *argv[])
           }
 
           if (precod_nbr_layers == 4) {
-            LOG_M("chestF5.m",
-                  "chF5",
-                  &pusch_vars->ul_ch_estimates[5][start_symbol * gNB->frame_parms.ofdm_symbol_size],
-                  gNB->frame_parms.ofdm_symbol_size,
-                  1,
-                  1 | log_format);
-            LOG_M("chestF10.m",
-                  "chF10",
-                  &pusch_vars->ul_ch_estimates[10][start_symbol * gNB->frame_parms.ofdm_symbol_size],
-                  gNB->frame_parms.ofdm_symbol_size,
-                  1,
-                  1 | log_format);
-            LOG_M("chestF15.m",
-                  "chF15",
-                  &pusch_vars->ul_ch_estimates[15][start_symbol * gNB->frame_parms.ofdm_symbol_size],
-                  gNB->frame_parms.ofdm_symbol_size,
-                  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))],

openair2/E2AP/RAN_FUNCTION/O-RAN/ran_func_rc_subs.c

@@ -23,9 +23,9 @@ void init_rc_subs_data(rc_subs_data_t *rc_subs_data)
 {
   pthread_mutex_lock(&rc_mutex);
   // Initialize sequence array
-  seq_arr_init(&rc_subs_data->rs1_param3, sizeof(ran_param_data_t));
-  seq_arr_init(&rc_subs_data->rs1_param4, sizeof(ran_param_data_t));
-  seq_arr_init(&rc_subs_data->rs4_param202, sizeof(ran_param_data_t));
+  rc_subs_data->rs1_param3 = seq_arr_init(sizeof(ran_param_data_t));
+  rc_subs_data->rs1_param4 = seq_arr_init(sizeof(ran_param_data_t));
+  rc_subs_data->rs4_param202 = seq_arr_init(sizeof(ran_param_data_t));
   pthread_mutex_unlock(&rc_mutex);
 }
 

openair2/GNB_APP/gnb_config.c

@@ -1238,7 +1238,7 @@ static seq_arr_t *fill_du_sibs(paramdef_t *GNBparamarray)
   }
 
   seq_arr_t *du_SIBs = malloc(sizeof(seq_arr_t));
-  seq_arr_init(du_SIBs, sizeof(nr_SIBs_t));
+  *du_SIBs = seq_arr_init(sizeof(nr_SIBs_t));
   for (int i = 0; i < GNBparamarray[GNB_DU_SIBS_IDX].numelt; i++) {
     int sib_value = GNBparamarray[GNB_DU_SIBS_IDX].iptr[i];
     // SIB10, SIB12, SIB13, SIB14, SIB15, SIB17, SIB18, SIB19 and SIB20 are generated by the DU
@@ -1980,7 +1980,7 @@ static seq_arr_t *fill_cu_sibs(paramdef_t *GNBparamarray)
   }
 
   seq_arr_t *SIBs = malloc(sizeof(seq_arr_t));
-  seq_arr_init(SIBs, sizeof(nr_SIBs_t));
+  *SIBs = seq_arr_init(sizeof(nr_SIBs_t));
   for (int i = 0; i < GNBparamarray[GNB_CU_SIBS_IDX].numelt; i++) {
     int sib_value = GNBparamarray[GNB_CU_SIBS_IDX].iptr[i];
     // SIB10, SIB12, SIB13, SIB14, SIB15, SIB17, SIB18, SIB19 and SIB20 are generated by the DU
@@ -2027,7 +2027,7 @@ static void fill_neighbour_cell_configuration(uint8_t gnb_idx, gNB_RRC_INST *rrc
     return;
 
   rrc->neighbour_cell_configuration = malloc(sizeof(seq_arr_t));
-  seq_arr_init(rrc->neighbour_cell_configuration, sizeof(neighbour_cell_configuration_t));
+  *rrc->neighbour_cell_configuration = seq_arr_init(sizeof(neighbour_cell_configuration_t));
 
   for (int elm = 0; elm < neighbour_list_param_list.numelt; ++elm) {
     neighbour_cell_configuration_t cell = {0};
@@ -2045,7 +2045,7 @@ static void fill_neighbour_cell_configuration(uint8_t gnb_idx, gNB_RRC_INST *rrc
       continue;
 
     cell.neighbour_cells = malloc_or_fail(sizeof(seq_arr_t));
-    seq_arr_init(cell.neighbour_cells, sizeof(nr_neighbour_cell_t));
+    *cell.neighbour_cells = seq_arr_init(sizeof(nr_neighbour_cell_t));
     for (int l = 0; l < NeighbourCellParamList.numelt; ++l) {
       nr_neighbour_cell_t n = {0};
       n.gNB_ID = *(NeighbourCellParamList.paramarray[l][GNB_CONFIG_N_CELL_GNB_ID_IDX].uptr);
@@ -2146,7 +2146,7 @@ static void fill_measurement_configuration(uint8_t gnb_idx, gNB_RRC_INST *rrc)
     return;
 
   measurementConfig->a3_event_list = malloc(sizeof(seq_arr_t));
-  seq_arr_init(measurementConfig->a3_event_list, sizeof(nr_a3_event_t));
+  *measurementConfig->a3_event_list = seq_arr_init(sizeof(nr_a3_event_t));
   for (int i = 0; i < A3_EventList.numelt; i++) {
     nr_a3_event_t a3_event = {0};
     a3_event.pci = *A3_EventList.paramarray[i][MEASUREMENT_EVENTS_PCI_ID_IDX].i64ptr;

openair2/LAYER2/NR_MAC_gNB/config.c

@@ -969,7 +969,7 @@ void nr_mac_config_scc(gNB_MAC_INST *nrmac, NR_ServingCellConfigCommon_t *scc, c
   if (IS_SA_MODE(get_softmodem_params()))
     config_sched_ctrlSIB1(nrmac);
 
-  seq_arr_init(&nrmac->ul_tda, sizeof(NR_tda_info_t));
+  nrmac->ul_tda = seq_arr_init(sizeof(NR_tda_info_t));
   init_ul_tda_info(scc->uplinkConfigCommon->initialUplinkBWP->pusch_ConfigCommon->choice.setup->pusch_TimeDomainAllocationList, &nrmac->ul_tda);
 }
 

openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_primitives.c

@@ -3001,7 +3001,7 @@ NR_UE_info_t *get_new_nr_ue_inst(uid_allocator_t *uia, rnti_t rnti, NR_CellGroup
   AssertFatal(UE->sc_info.n_ul_bwp <= NR_MAX_NUM_BWP, "uplinkBWP_ToAddModList has %d BWP!\n", UE->sc_info.n_ul_bwp);
 
   // initialize LCID structure
-  seq_arr_init(&sched_ctrl->lc_config, sizeof(nr_lc_config_t));
+  sched_ctrl->lc_config = seq_arr_init(sizeof(nr_lc_config_t));
   return UE;
 }
 

openair2/RRC/NR/rrc_gNB.c

@@ -761,10 +761,8 @@ NR_MeasConfig_t *nr_rrc_get_measconfig(const gNB_RRC_INST *rrc, uint64_t nr_cell
   if (cell->mtc != NULL) {
     NR_ReportConfigToAddMod_t *rc_PER = NULL;
     NR_ReportConfigToAddMod_t *rc_A2 = NULL;
-    seq_arr_t rc_A3_seq = {0};
-    seq_arr_t neigh_seq = {0};
-    seq_arr_init(&rc_A3_seq, sizeof(NR_ReportConfigToAddMod_t));
-    seq_arr_init(&neigh_seq, sizeof(nr_neighbour_cell_t));
+    seq_arr_t rc_A3_seq = seq_arr_init(sizeof(NR_ReportConfigToAddMod_t));
+    seq_arr_t neigh_seq = seq_arr_init(sizeof(nr_neighbour_cell_t));
 
     // Get cell info from the cell container
     int band = cell->info.mode == NR_MODE_TDD ? cell->info.tdd.dlul.band : cell->info.fdd.dl.band;

openair2/RRC/NR/rrc_gNB_NGAP.c

@@ -179,7 +179,7 @@ static void cp_pdusession_transfer_to_pdusession(pdusession_t *dst, const pduses
   DevAssert(!dst->qos.data);
   DevAssert(src->nb_qos < MAX_QOS_FLOWS);
   // Initialise mapped QoS list per PDU Session
-  seq_arr_init(&dst->qos, sizeof(nr_rrc_qos_t));
+  dst->qos = seq_arr_init(sizeof(nr_rrc_qos_t));
   // Add QoS flow to list
   for (uint8_t i = 0; i < src->nb_qos; ++i) {
     if (!add_qos(&dst->qos, &src->qos[i])) {

openair2/RRC/NR/rrc_gNB_UE_context.c

@@ -67,9 +67,8 @@ rrc_gNB_ue_context_t *rrc_gNB_allocate_new_ue_context(gNB_RRC_INST *rrc_instance
 rrc_gNB_ue_context_t *rrc_gNB_get_ue_context(gNB_RRC_INST *rrc_instance_pP, ue_id_t ue)
 //------------------------------------------------------------------------------
 {
-  rrc_gNB_ue_context_t temp;
-  /* gNB ue rrc id = 24 bits wide */
-  temp.ue_context.rrc_ue_id = ue;
+  rrc_gNB_ue_context_t temp = (rrc_gNB_ue_context_t){/* gNB ue rrc id = 24 bits wide */
+                                                     .ue_context.rrc_ue_id = ue};
   return RB_FIND(rrc_nr_ue_tree_s, &rrc_instance_pP->rrc_ue_head, &temp);
 }
 
@@ -202,11 +201,11 @@ rrc_gNB_ue_context_t *rrc_gNB_create_ue_context(sctp_assoc_t assoc_id,
   ue->ambr.ul_br = UINT64_MAX;
 
   // Initialise setup PDU Sessions list
-  seq_arr_init(&ue->pduSessions, sizeof(rrc_pdu_session_param_t));
+  ue->pduSessions = seq_arr_init(sizeof(rrc_pdu_session_param_t));
   // Initialise setup DRBs list
-  seq_arr_init(&ue->drbs, sizeof(drb_t));
+  ue->drbs = seq_arr_init(sizeof(drb_t));
   // Initialise serving cells list
-  seq_arr_init(&ue->serving_cells, sizeof(ue_serving_cell_t));
+  ue->serving_cells = seq_arr_init(sizeof(ue_serving_cell_t));
 
   RB_INSERT(rrc_nr_ue_tree_s, &rrc_instance_pP->rrc_ue_head, ue_context_p);
   LOG_UE_EVENT(ue,

openair2/RRC/NR/rrc_gNB_cuup.c

@@ -180,10 +180,8 @@ static bool has_assoc_id(const void *vval, const void *vit)
  * again. */
 static void remove_unassociated_e1_connections(gNB_RRC_INST *rrc)
 {
-  seq_arr_t affected_du;
-  seq_arr_init(&affected_du, sizeof(sctp_assoc_t));
-  seq_arr_t ue_context_to_remove;
-  seq_arr_init(&ue_context_to_remove, sizeof(rrc_gNB_ue_context_t *));
+  seq_arr_t affected_du = seq_arr_init(sizeof(sctp_assoc_t));
+  seq_arr_t ue_context_to_remove = seq_arr_init(sizeof(rrc_gNB_ue_context_t *));
 
   rrc_gNB_ue_context_t *ue_context_p = NULL;
   RB_FOREACH(ue_context_p, rrc_nr_ue_tree_s, &rrc->rrc_ue_head) {

openair2/RRC/NR/rrc_gNB_du.c

@@ -336,7 +336,7 @@ void rrc_gNB_process_f1_setup_req(f1ap_setup_req_t *req, sctp_assoc_t assoc_id)
   memcpy(du->rrc_ver, req->rrc_ver, sizeof(du->rrc_ver));
 
   // Initialize cell array for this DU
-  seq_arr_init(&du->cells, sizeof(nr_rrc_cell_container_t *));
+  du->cells = seq_arr_init(sizeof(nr_rrc_cell_container_t *));
   nr_rrc_du_container_t *du_collision = rrc_add_du(rrc, du);
   AssertFatal(du_collision == NULL, "rrc_add_du should succeed for new DU (assoc_id %d)", assoc_id);
 
@@ -462,8 +462,7 @@ void rrc_gNB_process_f1_setup_req(f1ap_setup_req_t *req, sctp_assoc_t assoc_id)
 static int invalidate_du_connections(gNB_RRC_INST *rrc, sctp_assoc_t assoc_id)
 {
   int count = 0;
-  seq_arr_t ue_context_to_remove;
-  seq_arr_init(&ue_context_to_remove, sizeof(rrc_gNB_ue_context_t *));
+  seq_arr_t ue_context_to_remove = seq_arr_init(sizeof(rrc_gNB_ue_context_t *));
   rrc_gNB_ue_context_t *ue_context_p = NULL;
   RB_FOREACH(ue_context_p, rrc_nr_ue_tree_s, &rrc->rrc_ue_head) {
     gNB_RRC_UE_t *UE = &ue_context_p->ue_context;

openair2/RRC/NR/tests/rrc_bearers_test.c

@@ -25,14 +25,10 @@ void exit_function(const char *file, const char *function, const int line, const
 static void test_rrc_pdu_session(void)
 {
   const int pdu_session_id = 3;
-  gNB_RRC_UE_t ue = {0};
-  seq_arr_init(&ue.pduSessions, sizeof(rrc_pdu_session_param_t));
+  gNB_RRC_UE_t ue = {.pduSessions = seq_arr_init(sizeof(rrc_pdu_session_param_t))};
 
   /* test add */
-  pdusession_t p1 = {0};
-  seq_arr_init(&p1.qos, sizeof(nr_rrc_qos_t));
-  p1.pdusession_id = pdu_session_id;
-  p1.n3_incoming.teid = 2002;
+  pdusession_t p1 = {.qos = seq_arr_init(sizeof(nr_rrc_qos_t)), .pdusession_id = pdu_session_id, .n3_incoming.teid = 2002};
   LOG_I(NR_RRC, "Adding first PDU Session with ID %d\n", p1.pdusession_id);
   rrc_pdu_session_param_t *s1 = add_pduSession(&ue.pduSessions, &p1); // add 1st PDU Session
   AssertFatal(s1 != NULL, "Could not add PDU Session\n");
@@ -47,17 +43,14 @@ static void test_rrc_pdu_session(void)
   LOG_A(NR_RRC, "PDU Session find test passed\n");
 
   /* test add duplicate */
-  pdusession_t input2 = {0};
-  seq_arr_init(&input2.qos, sizeof(nr_rrc_qos_t));
-  input2.pdusession_id = pdu_session_id;
-  input2.n3_incoming.teid = 9999;
+  pdusession_t input2 = {.qos = seq_arr_init(sizeof(nr_rrc_qos_t)), .pdusession_id = pdu_session_id, .n3_incoming.teid = 9999};
   rrc_pdu_session_param_t *s2 = add_pduSession(&ue.pduSessions, &input2); // add 2nd PDU Session
   AssertFatal(s2 == NULL, "Duplicated PDU session was added!\n");
   LOG_A(NR_RRC, "Duplicated PDU session test passed\n");
   seq_arr_free(&input2.qos, NULL);
 
   /* add DRB and fetch PDU Session */
-  seq_arr_init(&ue.drbs, sizeof(drb_t));
+  ue.drbs = seq_arr_init(sizeof(drb_t));
   nr_pdcp_configuration_t pdcp = {.drb.discard_timer = 100, .drb.sn_size = 18, .drb.t_reordering = 50};
   drb_t *added = nr_rrc_add_drb(&ue.drbs, pdu_session_id, &pdcp);
   AssertFatal(added != NULL, "Failed to add DRB");
@@ -73,16 +66,12 @@ static void test_rrc_pdu_session(void)
 static void test_rrc_drb(void)
 {
   LOG_I(NR_RRC, "Starting DRB test\n");
-  seq_arr_t pduSessions = {0};
-  seq_arr_t drbs = {0};
-  seq_arr_init(&pduSessions, sizeof(rrc_pdu_session_param_t));
-  seq_arr_init(&drbs, sizeof(drb_t));
+  seq_arr_t pduSessions = seq_arr_init(sizeof(rrc_pdu_session_param_t));
+  seq_arr_t drbs = seq_arr_init(sizeof(drb_t));
 
   /* test add 1 DRB to 1st PDU session */
   const int id1 = 1;
-  pdusession_t s1 = {0};
-  seq_arr_init(&s1.qos, sizeof(nr_rrc_qos_t));
-  s1.pdusession_id = id1;
+  pdusession_t s1 = {.qos = seq_arr_init(sizeof(nr_rrc_qos_t)), .pdusession_id = id1};
   add_pduSession(&pduSessions, &s1); // add PDU session
 
   nr_pdcp_configuration_t pdcp = {.drb.discard_timer = 100, .drb.sn_size = 18, .drb.t_reordering = 50};
@@ -96,9 +85,7 @@ static void test_rrc_drb(void)
 
   /* test add DRB to 2nd PDU session */
   const int id2 = 2;
-  pdusession_t s2 = {0};
-  seq_arr_init(&s2.qos, sizeof(nr_rrc_qos_t));
-  s2.pdusession_id = id2;
+  pdusession_t s2 = {.qos = seq_arr_init(sizeof(nr_rrc_qos_t)), .pdusession_id = id2};
   add_pduSession(&pduSessions, &s2); // add 2nd PDU session
   drb_t *in2 = nr_rrc_add_drb(&drbs, id2, &pdcp); // add DRB to 2nd PDU session
   AssertFatal(in2, "add_rrc_drb failed");
@@ -115,13 +102,10 @@ static void test_rrc_drb(void)
 
 static void test_rrc_qos(void)
 {
-  seq_arr_t pduSessions = {0};
-  seq_arr_init(&pduSessions, sizeof(rrc_pdu_session_param_t));
+  seq_arr_t pduSessions = seq_arr_init(sizeof(rrc_pdu_session_param_t));
 
   const int session_id = 70;
-  pdusession_t in = {0};
-  in.pdusession_id = session_id;
-  seq_arr_init(&in.qos, sizeof(nr_rrc_qos_t));
+  pdusession_t in = {.pdusession_id = session_id, .qos = seq_arr_init(sizeof(nr_rrc_qos_t))};
   add_pduSession(&pduSessions, &in);
   LOG_A(NR_RRC, "Created PDU Session %d for QoS test\n", session_id);
 

openair2/RRC/NR/tests/rrc_cell_management_test.c

@@ -76,7 +76,7 @@ static nr_rrc_du_container_t *create_test_du(sctp_assoc_t assoc_id, uint64_t du_
   du->gNB_DU_id = du_id;
   du->gNB_DU_name = strdup(name);
   AssertFatal(du->gNB_DU_name != NULL, "strdup failed for DU name");
-  seq_arr_init(&du->cells, sizeof(nr_rrc_cell_container_t *));
+  du->cells = seq_arr_init(sizeof(nr_rrc_cell_container_t *));
   return du;
 }
 
@@ -298,9 +298,7 @@ static void test_cell_lookup(void)
   AssertFatal(count_du2 == expected_du2_cells, "DU 2 should have %d cells (got %zu)", expected_du2_cells, count_du2);
 
   /* Sub-test 11: Test UE cell association - create test UE context */
-  gNB_RRC_UE_t ue = {0};
-  ue.rrc_ue_id = UE_ID;
-  seq_arr_init(&ue.serving_cells, sizeof(ue_serving_cell_t));
+  gNB_RRC_UE_t ue = {.rrc_ue_id = UE_ID, .serving_cells = seq_arr_init(sizeof(ue_serving_cell_t))};
 
   /* Register F1 UE data for this UE at the CU */
   f1_ue_data_t f1_data = {
@@ -411,8 +409,7 @@ static void test_cell_lookup(void)
   AssertFatal(ue_get_pcell_entry(&ue) == NULL, "PCell should be removed when it has matching assoc_id");
 
   /* Sub-test 18: Test rrc_get_pcell_for_ue() edge case (UE with no serving cells) */
-  gNB_RRC_UE_t ue_empty = {0};
-  seq_arr_init(&ue_empty.serving_cells, sizeof(ue_serving_cell_t));
+  gNB_RRC_UE_t ue_empty = {.serving_cells = seq_arr_init(sizeof(ue_serving_cell_t))};
   AssertFatal(rrc_get_pcell_for_ue(&rrc, &ue_empty) == NULL,
               "rrc_get_pcell_for_ue should return NULL for UE with no serving cells");
   seq_arr_free(&ue_empty.serving_cells, NULL);